diff --git a/content/docs/af-ZA/guides/ecs/entity-component-system.mdx b/content/docs/af-ZA/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/af-ZA/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/af-ZA/guides/ecs/example-ecs-plugin.mdx b/content/docs/af-ZA/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/af-ZA/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/af-ZA/guides/ecs/hytale-ecs-theory.mdx b/content/docs/af-ZA/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/af-ZA/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/af-ZA/guides/ecs/systems.mdx b/content/docs/af-ZA/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/af-ZA/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/af-ZA/guides/java-basics/00-introduction.mdx b/content/docs/af-ZA/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/af-ZA/guides/java-basics/00-introduction.mdx
+++ b/content/docs/af-ZA/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/af-ZA/guides/java-basics/06-methods-functions.mdx b/content/docs/af-ZA/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/af-ZA/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/af-ZA/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/af-ZA/guides/plugin/block-components.mdx b/content/docs/af-ZA/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/af-ZA/guides/plugin/browsing-serverjar.mdx b/content/docs/af-ZA/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/af-ZA/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/af-ZA/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/af-ZA/guides/plugin/build-and-test.mdx b/content/docs/af-ZA/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/af-ZA/guides/plugin/chat-formatting.mdx b/content/docs/af-ZA/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/af-ZA/guides/plugin/chat-formatting.mdx
+++ b/content/docs/af-ZA/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/af-ZA/guides/plugin/client-inputs-reference.mdx b/content/docs/af-ZA/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/af-ZA/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/af-ZA/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/af-ZA/guides/plugin/creating-block.mdx b/content/docs/af-ZA/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/af-ZA/guides/plugin/creating-block.mdx
+++ b/content/docs/af-ZA/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/af-ZA/guides/plugin/creating-commands.mdx b/content/docs/af-ZA/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/af-ZA/guides/plugin/creating-commands.mdx
+++ b/content/docs/af-ZA/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/af-ZA/guides/plugin/creating-configuration-file.mdx b/content/docs/af-ZA/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/af-ZA/guides/plugin/creating-events.mdx b/content/docs/af-ZA/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/af-ZA/guides/plugin/creating-events.mdx
+++ b/content/docs/af-ZA/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/af-ZA/guides/plugin/customizing-camera-controls.mdx b/content/docs/af-ZA/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/af-ZA/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/af-ZA/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/af-ZA/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/af-ZA/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/af-ZA/guides/plugin/instances.mdx b/content/docs/af-ZA/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/af-ZA/guides/plugin/inventory-management.mdx b/content/docs/af-ZA/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/af-ZA/guides/plugin/inventory-management.mdx
+++ b/content/docs/af-ZA/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/af-ZA/guides/plugin/item-interaction.mdx b/content/docs/af-ZA/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/af-ZA/guides/plugin/listening-to-packets.mdx b/content/docs/af-ZA/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/af-ZA/guides/plugin/logging.mdx b/content/docs/af-ZA/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/af-ZA/guides/plugin/player-death-event.mdx b/content/docs/af-ZA/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/af-ZA/guides/plugin/player-input-guide.mdx b/content/docs/af-ZA/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/af-ZA/guides/plugin/player-input-guide.mdx
+++ b/content/docs/af-ZA/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/af-ZA/guides/plugin/player-stats.mdx b/content/docs/af-ZA/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/af-ZA/guides/plugin/setting-up-env.mdx b/content/docs/af-ZA/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/af-ZA/guides/plugin/setting-up-env.mdx
+++ b/content/docs/af-ZA/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/af-ZA/guides/plugin/spawning-entities.mdx b/content/docs/af-ZA/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/af-ZA/guides/plugin/spawning-entities.mdx
+++ b/content/docs/af-ZA/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/af-ZA/guides/plugin/spawning-npcs.mdx b/content/docs/af-ZA/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/af-ZA/guides/plugin/store-persistant-data.mdx b/content/docs/af-ZA/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/af-ZA/guides/plugin/teleporting-players.mdx b/content/docs/af-ZA/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/af-ZA/guides/plugin/teleporting-players.mdx
+++ b/content/docs/af-ZA/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/af-ZA/guides/plugin/text-hologram.mdx b/content/docs/af-ZA/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/af-ZA/guides/plugin/ui.mdx b/content/docs/af-ZA/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/af-ZA/guides/plugin/world-gen.mdx b/content/docs/af-ZA/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/af-ZA/guides/plugin/world-gen.mdx
+++ b/content/docs/af-ZA/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/af-ZA/guides/prefabs.mdx b/content/docs/af-ZA/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/af-ZA/guides/prefabs.mdx
+++ b/content/docs/af-ZA/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/af-ZA/official-documentation/npc-doc.mdx b/content/docs/af-ZA/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/af-ZA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/af-ZA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/af-ZA/publishing/builtbybit.mdx b/content/docs/af-ZA/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/af-ZA/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/af-ZA/publishing/index.mdx b/content/docs/af-ZA/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/af-ZA/publishing/index.mdx
+++ b/content/docs/af-ZA/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/ar-SA/guides/ecs/entity-component-system.mdx b/content/docs/ar-SA/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/ar-SA/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/ar-SA/guides/ecs/example-ecs-plugin.mdx b/content/docs/ar-SA/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/ar-SA/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/ar-SA/guides/ecs/hytale-ecs-theory.mdx b/content/docs/ar-SA/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/ar-SA/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/ar-SA/guides/ecs/systems.mdx b/content/docs/ar-SA/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/ar-SA/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/ar-SA/guides/java-basics/00-introduction.mdx b/content/docs/ar-SA/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/ar-SA/guides/java-basics/00-introduction.mdx
+++ b/content/docs/ar-SA/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/ar-SA/guides/java-basics/06-methods-functions.mdx b/content/docs/ar-SA/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/ar-SA/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/ar-SA/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/ar-SA/guides/plugin/block-components.mdx b/content/docs/ar-SA/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/ar-SA/guides/plugin/browsing-serverjar.mdx b/content/docs/ar-SA/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/ar-SA/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/ar-SA/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/ar-SA/guides/plugin/build-and-test.mdx b/content/docs/ar-SA/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/ar-SA/guides/plugin/chat-formatting.mdx b/content/docs/ar-SA/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/ar-SA/guides/plugin/chat-formatting.mdx
+++ b/content/docs/ar-SA/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/ar-SA/guides/plugin/client-inputs-reference.mdx b/content/docs/ar-SA/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/ar-SA/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/ar-SA/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/ar-SA/guides/plugin/creating-block.mdx b/content/docs/ar-SA/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/ar-SA/guides/plugin/creating-block.mdx
+++ b/content/docs/ar-SA/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/ar-SA/guides/plugin/creating-commands.mdx b/content/docs/ar-SA/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/ar-SA/guides/plugin/creating-commands.mdx
+++ b/content/docs/ar-SA/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/ar-SA/guides/plugin/creating-configuration-file.mdx b/content/docs/ar-SA/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/ar-SA/guides/plugin/creating-events.mdx b/content/docs/ar-SA/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/ar-SA/guides/plugin/creating-events.mdx
+++ b/content/docs/ar-SA/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/ar-SA/guides/plugin/customizing-camera-controls.mdx b/content/docs/ar-SA/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/ar-SA/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/ar-SA/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/ar-SA/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/ar-SA/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/ar-SA/guides/plugin/instances.mdx b/content/docs/ar-SA/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/ar-SA/guides/plugin/inventory-management.mdx b/content/docs/ar-SA/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/ar-SA/guides/plugin/inventory-management.mdx
+++ b/content/docs/ar-SA/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/ar-SA/guides/plugin/item-interaction.mdx b/content/docs/ar-SA/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/ar-SA/guides/plugin/listening-to-packets.mdx b/content/docs/ar-SA/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/ar-SA/guides/plugin/logging.mdx b/content/docs/ar-SA/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/ar-SA/guides/plugin/player-death-event.mdx b/content/docs/ar-SA/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/ar-SA/guides/plugin/player-input-guide.mdx b/content/docs/ar-SA/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/ar-SA/guides/plugin/player-input-guide.mdx
+++ b/content/docs/ar-SA/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/ar-SA/guides/plugin/player-stats.mdx b/content/docs/ar-SA/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/ar-SA/guides/plugin/setting-up-env.mdx b/content/docs/ar-SA/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/ar-SA/guides/plugin/setting-up-env.mdx
+++ b/content/docs/ar-SA/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/ar-SA/guides/plugin/spawning-entities.mdx b/content/docs/ar-SA/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/ar-SA/guides/plugin/spawning-entities.mdx
+++ b/content/docs/ar-SA/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/ar-SA/guides/plugin/spawning-npcs.mdx b/content/docs/ar-SA/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/ar-SA/guides/plugin/store-persistant-data.mdx b/content/docs/ar-SA/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/ar-SA/guides/plugin/teleporting-players.mdx b/content/docs/ar-SA/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/ar-SA/guides/plugin/teleporting-players.mdx
+++ b/content/docs/ar-SA/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/ar-SA/guides/plugin/text-hologram.mdx b/content/docs/ar-SA/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/ar-SA/guides/plugin/ui.mdx b/content/docs/ar-SA/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/ar-SA/guides/plugin/world-gen.mdx b/content/docs/ar-SA/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/ar-SA/guides/plugin/world-gen.mdx
+++ b/content/docs/ar-SA/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/ar-SA/guides/prefabs.mdx b/content/docs/ar-SA/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/ar-SA/guides/prefabs.mdx
+++ b/content/docs/ar-SA/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/ar-SA/official-documentation/npc-doc.mdx b/content/docs/ar-SA/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/ar-SA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/ar-SA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/ar-SA/publishing/builtbybit.mdx b/content/docs/ar-SA/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/ar-SA/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/ar-SA/publishing/index.mdx b/content/docs/ar-SA/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/ar-SA/publishing/index.mdx
+++ b/content/docs/ar-SA/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/cs-CZ/contributing/index.mdx b/content/docs/cs-CZ/contributing/index.mdx
new file mode 100644
index 00000000..ac05eb21
--- /dev/null
+++ b/content/docs/cs-CZ/contributing/index.mdx
@@ -0,0 +1,39 @@
+---
+title: Contributing
+---
+
+# Contributing to HytaleModding
+
+We welcome contributions from the community to help improve and expand the HytaleModding documentation. Whether you're fixing typos, adding new tutorials, or providing code examples, your contributions are valuable!
+
+## How to Contribute
+
+### Reporting Issues
+
+If you've found a issue with the documentation, please report it by opening a new issue on our [GitHub repository](https://github.com/HytaleModding/site/issues).
+
+If you can work on this issue yourself, you can ask to be assigned to it and submit a PR.
+
+### Submitting Pull Requests
+
+1. Fork the repository on GitHub.
+2. Clone your fork to your local machine.
+3. Create a new branch for your changes.
+
+```bash
+git checkout -b my-feature-branch
+```
+
+4. Make your changes and commit them with clear messages. We follow [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/), your PR will not be accepted if your commit messages do not follow this convention.
+
+```bash
+git commit -m "Add feature X to documentation"
+```
+
+5. Push your changes to your fork.
+
+```bash
+git push origin my-feature-branch
+```
+
+6. Open a Pull Request on the original repository, describing your changes and why they should be merged.
diff --git a/content/docs/cs-CZ/contributing/pr-guidelines.mdx b/content/docs/cs-CZ/contributing/pr-guidelines.mdx
new file mode 100644
index 00000000..7a251032
--- /dev/null
+++ b/content/docs/cs-CZ/contributing/pr-guidelines.mdx
@@ -0,0 +1,39 @@
+---
+title: PR Guidelines
+description: Guidelines that reviewers and contributors should follow when submitting and reviewing pull requests.
+---
+
+# Pull Request Guidelines
+
+To ensure a smooth and efficient review process, both contributors and reviewers should adhere to the following guidelines when submitting and reviewing pull requests (PRs).
+
+## For Contributors
+
+1. **Descriptive Titles and Descriptions**
+   - Use clear and concise titles that summarize the changes.
+   - Provide detailed descriptions of what the PR does, why the changes are necessary, and any relevant context.
+2. **Link to Issues**
+   - In your PR title, add `GH-ISSUE-NUMBER` to link the PR to the relevant issue. This is required for all PRs.
+3. **Small, Focused Changes**
+   - Aim to keep PRs small and focused on a single issue or feature. This makes it easier for reviewers to understand and provide feedback.
+4. **Code Quality**
+   - Ensure your code follows the project's coding standards and best practices.
+   - Include comments where necessary to explain complex logic.
+5. **Testing**
+   - Test your changes thoroughly before submitting the PR.
+   - If applicable, include unit tests or integration tests to verify your changes.
+6. **Documentation**
+   - Update or add documentation as needed to reflect your changes.
+7. **Commit Messages**
+   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
+8. **Check for Conflicts**
+   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+
+## For Reviewers
+
+- You are supposed to review PRs thoroughly, and request changes if needed.
+- Provide constructive feedback and suggestions for improvement.
+- Verify that the changes meet the project's coding standards and best practices.
+- Deploy the PR using the dokploy integration to ensure the changes work as expected.
+- Ensure that documentation is updated as necessary.
+- Approve the PR only when you are satisfied with the changes and all checks have passed.
diff --git a/content/docs/cs-CZ/contributing/writing-guides.mdx b/content/docs/cs-CZ/contributing/writing-guides.mdx
new file mode 100644
index 00000000..55c52ade
--- /dev/null
+++ b/content/docs/cs-CZ/contributing/writing-guides.mdx
@@ -0,0 +1,86 @@
+---
+title: Writing Guides
+---
+
+## Creating a guide file
+
+To start writing a guide, you need to create a file with extension `.mdx`. You need to create this file inside the `/content/docs/en` directory, now it depends in which section you want to make the guide, so you can decide which folder you should put it in after that.
+
+Suppose I want to make a java basics guide, I'd put it in `/content/docs/en/guides/java-basics`. You'll have to do some digging to find out where you want to place it.
+
+<Callout>
+  If there's already a guide in the section you want to write about, you can just press on the "Edit On GitHub" button on our website and it'll take you to the folder, now you can write in the same folder to have your guide appear in the same section.
+</Callout>
+
+## Frontmatter
+
+Frontmatter is the metadata of your guide, it tells our website how to display your guide. This needs to be at the very top of the file, which starts with `---` and ends with `---`.
+
+Here's an example:
+
+```mdx
+---
+title: "Java Basics"
+description: "Learn the basics of Java programming."
+authors:
+    - name: "Your Name"
+      url: "https://yourwebsite.com"
+---
+```
+
+Now as you can see, it's pretty self explanatory, you just need to fill in the details for your specific guide. If you don't have a URL you want to link yourself to, just don't write that whole line. Additionally, the authors section is optional, so if you don't want to add it, you can just leave it out although we encourage you to do so and credit yourself.
+
+The indentation in the frontmatter is important, so make sure to keep it consistent with the example.
+
+## Content Structure
+
+You should structure the content of your guide in a clear and organized manner. Here are some tips on how to do that:
+
+- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
+- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
+- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
+- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
+- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+
+Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+
+When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+
+## Formatting
+
+We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+
+- Use headings (`#`, `##`, `###`) to organize your content.
+- Use bullet points and numbered lists for clarity.
+- Use code blocks (\`\`\`) for code snippets.
+- Use links to reference other guides or external resources.
+
+This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+
+You can also make a Callout to highlight important information or tips. Use the following syntax:
+
+```mdx
+<Callout>
+    This is a callout message.
+</Callout>
+```
+
+<Callout>
+  This is a callout message.
+</Callout>
+
+You can change the color of the callout by adding a `type` attribute. For example:
+
+```mdx
+<Callout type="info">
+    This is an info callout.
+</Callout>
+```
+
+Available types are: `info`, `warning`, `error`, and `success`.
+
+## Conclusion
+
+That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+
+Happy writing!
diff --git a/content/docs/cs-CZ/established-information/client/index.mdx b/content/docs/cs-CZ/established-information/client/index.mdx
new file mode 100644
index 00000000..39e863f6
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/client/index.mdx
@@ -0,0 +1,69 @@
+---
+title: The Hytale Client
+description: Information regarding the Hytale client.
+---
+
+<Callout>
+  The client is written in C#, compiled to machine code before distribution, and not moddable. Single-player runs on a local server. All mods must go through the server API.
+</Callout>
+
+# No Client-Side Mods
+
+There is no client-side modding.
+
+> We don't intend to support any client mods - Slikey
+
+## Why?
+
+1. No need to download externally.
+   * Hytale wants to "avoid a fragmented ecosystem where every server requires a different modded client".
+
+2. Client security.
+   * Running `.jar` files from third-party sites on the client can easily introduce malware.
+   > [We don't want to expose players] to the security and safety risks that exist on some other modding platform.
+
+3. Client stability.
+   * Hytale may move to other platforms on which client modding is impossible, so they're locking it down early to set the right direction early.
+   > We believe that the results that people get in other block games using client mods can be easily achieved using our server-sided modding. In other block games you have to install a client mod in order to get new blocks, NPCs, UI, etc.Hytale does all of that just by listening to the server. The server will basically "mod" the client temporarily in a really safe way to add and modify your gameplay experience. You could make your very own version of Orbis, using none of our models, music, world generation, combat or anything. You have control and you can rip it all out without ever touching the client. Think about how Roblox works.. You never change your App. You just click on an experience you want and you get all you need without modding your installation itself. - Slikey
+
+## Client Mods are Not Needed
+
+The typical use cases for client mods are:
+
+* Cosmetic changes (resource packs, shaders, capes, etc.): servers own visuals, not the client.
+* Performance: the base game will offer necessary performance controls.
+* Accessibility: the base game will be accessible on its own.
+* User Interface: servers own UI, not the client.
+
+### Client-Side Prediction
+
+Hytale uses data-driven client-side prediction to mitigate lag, as all interactions take place on the server and are relayed back to the client. This is already present for some systems but currently limited, though further integration is planned for the future. It's also planned to work with the visual scripting system in the future for further optimization.
+
+## Client-Side Execution
+
+The team is exploring allowing execution of code by the client (which is distinct from modding the client; this is code sent from the server), though this is not guaranteed.
+
+# Models
+
+The client and assets pipeline accepts `.blockymodel`, a custom format for Hytale. The official Blockbench plugin will allow you to export to this format.
+
+# Client Technical Details
+
+There will only ever be one current, supported version of the client.
+
+> Java version will be kept updated by us and right now we are on the latest version (Java 25)
+> The game version will not be selectable to avoid the version jungle we experienced on our hypixel server network. We simply want to make sure that multiplayer networks can rely on players having the latest version of the game to not have to support 15+ versions of the client. - Slikey
+
+The client is multithreaded.
+
+## GUI
+
+The GUI is built from C# bindings using Noesis.
+
+## Build System
+
+Hytale uses NativeAOT ("Ahead of Time") to build the client, which compiles C# to machine code for distribution. This means that, without reverse-engineering the machine code, mods will have to go through the server API.
+
+# Other Information
+
+The client has its own versioning and protocol to interact with servers.
diff --git a/content/docs/cs-CZ/established-information/developer-qa-insights.mdx b/content/docs/cs-CZ/established-information/developer-qa-insights.mdx
new file mode 100644
index 00000000..47915c97
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/developer-qa-insights.mdx
@@ -0,0 +1,125 @@
+---
+title: Developer Q&A Technical Insights
+description: Comprehensive summary of technical insights from Hytale developers covering architecture, modding, gameplay systems, and development philosophy.
+---
+
+# Developer Q&A Technical Insights
+
+This extensive Q&A session with Hytale developers reveals critical technical details about the game's architecture, modding philosophy, gameplay systems, and development approach.
+
+## Technical Architecture
+
+### Network & Infrastructure
+
+* **Protocol**: Uses QUIC (reliable UDP with unreliable channels) instead of TCP
+* **Server Compatibility**: Runs on any platform supporting Java 25
+* **Connection Method**: Direct IP initially, server discovery planned post-launch
+* **Data Layer**: Current custom serialization format will be replaced post-launch
+* **Performance**: Multi-core support - each world has main thread + parallel execution
+* **Rendering**: OpenGL 3.3 for Mac compatibility, potential future Vulkan/Metal migration
+* **Tick Model**: Base server tick rate is 30 TPS by default; can be changed using server plugins.
+
+### Security & Distribution
+
+* **No Client-Side Code Execution**: Prevents remote code execution exploits
+* **Downloads Limited To**: Configuration files and assets only
+* **Mod Distribution**: Community platforms (CurseForge, Modrinth), no immediate in-game marketplace
+* **Server Hosting**: Available day 1, no business agreements required (just EULA/TOS)
+
+## Modding Capabilities
+
+### Server-Side Power
+
+* **Full Java Access**: Database connections, web requests, any Java functionality
+* **Custom Libraries**: Can create Lua scripting, ML frameworks, or any Java library
+* **Server Modification**: Shared source code allows heavy server modifications
+* **Hot Reload**: Supported for most asset types
+* **Documentation**: Public GitBook planned, though initially sparse
+
+### Content Creation (No Code Required)
+
+* **World Generation**: Custom biomes and maps without Java
+* **NPCs & Items**: JSON-based configuration
+* **Crafting Recipes**: Data-driven system
+* **Visual Scripting**: Replaces command blocks, fully sandboxed
+* **Prefab System**: Sophisticated building blocks with in-game editor
+
+### Advanced Modding
+
+* **Combat System**: Data-driven interaction system for attack chains and abilities
+* **Sub-Hitboxes**: Support for complex boss mechanics (needs improvement)
+* **Status Effects**: Buff/debuff system with custom effects and stats
+* **Custom UI**: NoesisGUI transition enables powerful interface customization
+* **Block Physics**: Selective system (trees fall, but placed blocks don't)
+
+## Gameplay Systems
+
+### Core Mechanics
+
+* **Stamina System**: No hunger by default (can be modded in)
+* **Gravity**: Selective block physics - trees collapse, buildings can float
+* **Lighting**: Major overhaul to fix model/voxel inconsistencies
+* **World Height**: Currently limited, may change with voxel storage updates
+* **Automation**: No redstone equivalent at launch (moddable)
+
+### Player Systems
+
+* **Character Models**: Humans by default, changeable in creative mode
+* **Multiplayer Avatars**: Server-controlled (no custom models in multiplayer)
+* **Skins**: Full customization possible ("mod yourself into a potato")
+* **Shapeshifting**: Transformation potions exist for fun/modding
+
+### World & NPCs
+
+* **Faction System**: Living world with dynamic NPC interactions
+* **Village Systems**: Planned dynamic villages with relationships and behaviors
+* **Chunk Loading**: Entities unload when out of all players' render distance
+* **Seeds**: Shareable world generation seeds supported
+
+## Development Philosophy
+
+### Release Strategy
+
+* **Base Game Priority**: Adventure mode is primary focus, modding architecture supports it
+* **Tech Debt**: Acknowledged as necessary for release, commitment to improvement
+* **Update Frequency**: Very frequent updates planned, especially post-launch
+* **Version Policy**: Always latest version, but servers can run modified versions
+
+### Community Focus
+
+* **Creator Support**: Development bounties planned for community contributors
+* **Tutorials**: Official modding tutorials planned with partners
+* **Feedback Integration**: Strong commitment to community-driven improvements
+* **Accessibility**: Designed for lower-end hardware, reasonable system requirements
+
+### Tools & Documentation
+
+* **Blockbench Integration**: Replaces custom "Hytale Model Maker"
+* **Machinima Tools**: Full cinematic creation capabilities
+* **Creative Tools**: Major reveal planned for building/creation features
+* **Source Access**: Server code will be unobfuscated with developer comments
+
+## Platform Support
+
+* **Current**: Windows (primary)
+* **Planned**: Mac/Linux support actively in development
+* **VR**: Not feasible in near future
+* **Performance**: Uncapped framerate, designed for accessibility
+* **Offline Play**: Single-player works without internet connection
+
+## Monetization & Legal
+
+* **No Pay-to-Win**: Firm commitment against P2W mechanics
+* **Cosmetics Only**: Low-price cosmetic packs to support infrastructure
+* **Server EULA**: Terms being finalized for server monetization policies
+* **QUIC Blocking**: Acknowledged issue in some regions, no alternative protocol
+
+## Current Limitations
+
+* **Custom Shaders**: Not supported until sandboxing solution found
+* **UI/Input Limitations**: Being expanded but currently restricted
+* **Documentation**: Sparse initially, will improve over time
+* **Client Mods**: No client-side code execution for security
+* **Nameplates**: Currently limited customization
+
+This comprehensive technical foundation positions Hytale as a secure, extensible platform that empowers creators while maintaining performance, accessibility, and a commitment to continuous improvement.
diff --git a/content/docs/cs-CZ/established-information/faq.mdx b/content/docs/cs-CZ/established-information/faq.mdx
new file mode 100644
index 00000000..f9b651ef
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/faq.mdx
@@ -0,0 +1,45 @@
+---
+title: Frequently Asked Questions
+description: Frequently Asked Questions about Hytale modding.
+---
+
+On this page, we'll answer some of your Frequently Asked Questions.
+
+## 1. Can the client be modded?
+
+No, the client is not able to be modded, although the Client will not have control over how the game and the UI looks.
+
+The server decides the visuals, more like the "Resource Packs" available in Minecraft. The server decides what mods are used
+
+## 2. What Network Protocol will be used?
+
+Hytale will use the QUIC transport protocol.
+
+For context, the two main Internet protocols are UDP and TCP.
+
+* UDP is connectionless, fast, fire-and-forget packets but has less reliability as packets can be lost.
+* TCP is connection-based, slower than UDP, can guarantee packet delivery with much more reliability.
+  Both are pretty fast in modern times, games can run fine on both (but generally prefer UDP).
+
+QUIC is a **hybrid protocol** that builds off UDP to get the same speed benefits, but adds some layers of reliability like TCP.
+Essentially, a solid choice for game development that blends speed and reliability.
+
+## 3. What are Transfer Packets?
+
+Transfer packets in Hytale are small data payloads *(4kb)* that allow players to move from one server to another while carrying information.
+They are not equivalent to something like BungeeCord or Velocity and are primarily intended for smaller servers.
+
+Unlike BungeeCord, they do not manage network-wide features such as global plugins.
+Implementing DDOS protection would also be incredibly hard for smaller networks by using transfer packets.
+
+Transfer packets work quite well in scenarios such as small server networks or hubs where players will hop between servers without the loss of progress. For example, a player might finish a dungeon on one server and then move to a lobby or different game mode with their inventory and stats intact. This lessens server costs and enables the developers to put more effort into gameplay improvement rather than complicated network setups.
+
+## 4. Will Hytale support dedicated servers?
+
+Yes, Hytale will support dedicated servers. This allows server owners to host their own Hytale servers on their own hardware or through third-party hosting services.
+
+Dedicated servers provide more control over server settings, mods, and performance compared to using official hosting solutions.
+
+## 5. Will Hytale support modding on consoles?
+
+As of now, Hytale modding is primarily focused on PC platforms.
diff --git a/content/docs/cs-CZ/established-information/gameplay/creative.mdx b/content/docs/cs-CZ/established-information/gameplay/creative.mdx
new file mode 100644
index 00000000..c2c4e4b4
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/gameplay/creative.mdx
@@ -0,0 +1,243 @@
+---
+title: Creative
+description: Information regarding the creative mode in Hytale.
+---
+
+# Creative Mode
+
+Creative mode in Hytale is a sandbox mode that allows players to edit the world freely.
+
+## World Editing Tools
+
+Creative mode includes a variety of tools to help players edit the world. It includes undo functionality for edits.
+
+Note that the below sections were unnamed in the video demo of the tools.
+
+---
+
+### Laser Pointer
+
+Displays a ray from the player's camera in the direction the player is looking.
+
+#### Settings
+
+- Duration (Integer Slider): Description unknown as of December 2025.
+- Laser Color (Hex Color Code): Description unknown as of December 2025.
+
+### Sculpt Brush Tool
+
+Allows the user to raise and lower the terrain to more accurately sculpt and blend shapes. Supports most features of the Paint Brush.
+
+### Line Brush Tool
+
+Unknown as of December 2025.
+
+### Selection Tool
+
+Allows the user to select and edit regions of the world by transforming selections of blocks or a prefab via position, rotation, and extrusion.
+
+#### Settings
+
+- Mode (Combo Box: Set, Wall, Fill, Replace): Description unknown as of December 2025.
+- Material (Integer Slider): Description unknown as of December 2025.
+- Weight (Integer Slider): Description unknown as of December 2025.
+- Pitch (Integer): Description unknown as of December 2025.
+
+### Ruler
+
+Allows the user to measure distances between multiple points in 3D space, with support for multiple measurement lines and editing of measured points.
+
+### Layer Brush Tool
+
+Unknown as of December 2025.
+
+### Paste Tool
+
+Allows the user to paste a copied selection of blocks or a prefab at the point at which the player is looking. The paste is relative to the selection's anchor point. If the selection is a prefab, the anchor point may be set in the Prefab Editor. It is unknown if the selection's anchor may be set otherwise.
+
+### Flood Brush Tool
+
+Unknown as of December 2025.
+
+### Paint Brush Tool
+
+Brushes are used to make large changes to the world from far away.
+
+#### General Abilities
+
+- Place Shapes and Prefabs
+- Replace Blocks
+- Create Axis Locks and Masks
+
+#### Settings
+
+- Material
+- Width (Integer Slider): Description unknown as of December 2025.
+- Height (Integer Slider): Description unknown as of December 2025.
+- Shape (Combo Box: Cube, Sphere, Cylinder, Cone, Inverted Cone, Pyramid, Inverted Pyramid, Cuboid Grid): Description unknown as of December 2025.
+- Origin (Combo Box: Center, Bottom, Top): Description unknown as of December 2025.
+- Mirror Axis (Combo Box: None, Unknown other options): Description unknown as of December 2025.
+- Wall Thickness (Integer Slider): Description unknown as of December 2025.
+- Density (Integer Slider): Description unknown as of December 2025.
+
+#### Presets:
+
+- Boulder: Creates a boulder at the point at which the player is looking.
+- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
+- Rubble: Generate rubble at the point at which the player is looking.
+- Tentacle: TBD
+- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
+- Hot Springs: TBD
+- Ruins: Generates a ruin at the point at which the player is looking.
+- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
+- Grass: TBD
+- Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
+- Ruins: TBD
+
+---
+
+### Entity Grabber Tool
+
+Unknown as of December 2025.
+
+### Noise Brush Tool
+
+Unknown as of December 2025.
+
+### Scatter Brush Tool
+
+Unknown as of December 2025.
+
+### Extrude Brush Tool
+
+Unknown as of December 2025.
+
+### Prefab Selector Tool
+
+Allows the user to select a prefab when inside the Prefab Editor. May be used with the copy command.
+
+### Smooth Brush Tool
+
+Unknown as of December 2025.
+
+### Hitbox Tool
+
+Unknown as of December 2025.
+
+### Set Anchor Tool
+
+Allows the user to set an anchor point for a prefab when inside the Prefab Editor.
+
+### Tint Brush Tool
+
+Unknown as of December 2025.
+
+---
+
+## Creative Mode Quick Settings
+
+Note that these are WIP and subject to change. **Not all settings and functionality are currently known**.
+
+- Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
+- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
+- Brush Opacity (Integer Slider): Description unknown as of December 2025.
+- Selection Opacity (Integer Slider): Description unknown as of December 2025.
+- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
+- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
+- Display Legend (Toggle): Description unknown as of December 2025.
+- Show Tool Notifications (Toggle): Description unknown as of December 2025.
+- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
+- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
+- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
+- Flight Intertia (Integer Slider): Description unknown as of December 2025.
+- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
+- No Clip (Toggle): Description unknown as of December 2025.
+- Air Placement (Toggle): Description unknown as of December 2025.
+
+## Content Creation Tools
+
+Hytale includes a variety of built-in content creation tools to help players create and edit content.
+
+### Asset Editor
+
+Unknown as of December 2025.
+
+### Model Editor
+
+Unknown as of December 2025.
+
+### Asset Node Editor
+
+Unknown as of December 2025.
+
+### World Tools
+
+These are tools that allow the user to directly edit the current world.
+
+#### Prefab Editor
+
+Allows the user to create or edit prefabs in a separate space.
+
+##### Settings
+
+- Saved configs (Unknown type; presumably a file)
+- Root Dir (Unknown type; presumably a folder)
+- Prefab Paths or Folders (Unknown type; presumably a list of paths or folders)
+- Recursively Search for Prefabs (Toggle)
+- Spawn Entities and NPCs (Toggle)
+- Desired Y Level to Paste (Integer)
+- Blocks Between Prefabs (Integer)
+- WorldGen Type (Combo Box: Flat, Unknown other options): Description unknown as of December 2025.
+- (Flat WorldGen Only) Num Air Blocks Below Prefabs (Integer): Description unknown as of December 2025.
+- Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
+- Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
+
+#### Prefab List
+
+- Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
+- User can pick from server, assets, or worldgen prefabs.
+
+#### Spawn NPC
+
+Unknown as of December 2025.
+
+#### Spawn Particle
+
+Unknown as of December 2025.
+
+#### Change Player Model
+
+- Allows the player to change their model with an adjustable scale.
+
+#### Tint Chunk
+
+Unknown as of December 2025.
+
+#### Instances
+
+Unknown as of December 2025.
+
+### Builder Tools
+
+Unknown as of December 2025.
+
+### Machinima
+
+Machinima is a built-in sequence editor, allowing the user to create and edit sequences of actions to be played back in game. It includes a built-in interactive keyframe editor.
+
+The speed of playback can be adjusted via commands.
+
+The user may add actors for the sequence to control.
+
+- Reference
+- Camera
+- Entity
+- Item
+- Player
+
+## Commands
+
+Commands are entered into the world's chat console and begin with a forward slash `/`.
+
+- `set <block>`: allows the user to set the blocks in a selection to the specified block.
+- `inventory clear`: allows the user to clear their inventory.
diff --git a/content/docs/cs-CZ/established-information/server-plugin-insights.mdx b/content/docs/cs-CZ/established-information/server-plugin-insights.mdx
new file mode 100644
index 00000000..40c8ae52
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/server-plugin-insights.mdx
@@ -0,0 +1,93 @@
+---
+title: Server Code Insights
+description: Slikey shared some insights about server code on 12/15/2025. This document covers key points and takeaways from that discussion.
+---
+
+<Callout type="info" title="Note">
+  The following information is based on insights shared by Technical Director Slikey on December 15, 2025 on the Hytale Discord Server. It provides an overview of the server code architecture and plugin capabilities.
+
+  Majority of this document is just straight quotes from Slikey with minimal commentary. It is more over to preserve the information shared rather than reword it.
+</Callout>
+
+# Server Source Code
+
+The server will be released as shared source - we will have the source code with no obfuscation and all their comments.
+
+### License
+
+The license permits usage for any **hytale related** things, so as long as you dont use the server / source to make your own game or sell their algorithms.
+
+# Permission system
+
+After being asked in the Hytale Modding server, Lead Architect Zero has replied:
+
+It's quite basic, so don't expect much but yes we do have a permissions system built in. It also support implementing your own backend. Ex. if you wanted to store it in a database.
+
+![Premission Source Snippet](/assets/premission-system.png)
+
+# World Gen Implementation
+
+The following block of text is directly from Lead Architect Zero:
+
+You can totally implement a custom world gen in a plugin super easy. So if you want a totally different config or logic for generating terrain you can add that into a plugin and then configure a world to use that,
+We have some stuff load prefabs and there is existing code in the current world generators that could possibly be reused but no APIs specifically for the details of the generation itself.
+
+```java
+public interface IWorldGenProvider {
+    BuilderCodecMapCodec<IWorldGenProvider> CODEC = new BuilderCodecMapCodec<>("Type", true);
+
+    IWorldGen getGenerator() throws WorldGenLoadException;
+}
+```
+
+```java
+public interface IWorldGen {
+    @Nullable
+    WorldGenTimingsCollector getTimings();
+
+    CompletableFuture<GeneratedChunk> generate(int seed, long index, int x, int z, LongPredicate stillNeeded);
+
+    @Deprecated
+    Transform[] getSpawnPoints(int seed);
+
+    @Nonnull
+    default ISpawnProvider getDefaultSpawnProvider(int seed) {
+        return new FitToHeightMapSpawnProvider(new IndividualSpawnProvider(getSpawnPoints(seed)));
+    }
+
+    default void shutdown() {}
+}
+```
+
+# Server Code Snippets
+
+Some code snippets from a plugin they made were also shared. The following snippets are directly quoted from Technical Director Slikey:
+
+## BlockSpawner Plugin
+
+Alright, I'll drop some code snippets here for a simple plugin called "BlockSpawner" which will turn into a "random" block when put into the world based on the configured rules
+
+There is more code here in general but it shows the Asset System and the plugin layout. You can see that the asset system defines "Codecs" which are used to serialize and deserialize data. Using these codecs we can generate schemas.
+Let's say you connect to a server and open the asset editor: the server will send those schemas - so every single asset type defined server side, even you own, now become part of the asset editor on the client - no need to do anything, you just get to enjoy the editor UI for making your assets that you defined
+
+![Block Spawner Code 1](/assets/blockspawner-code-1.png)
+![Block Spawner Code 2](/assets/blockspawner-code-2.png)
+![Block Spawner Code 3](/assets/blockspawner-code-3.png)
+![Block Spawner Manifest](/assets/blockspawner-manifest.png)
+
+> i guess this part also shows a bit how we use constants to store some language keys - Slikey
+> (in reference to the image below)
+
+![Constants to store Language Keys](/assets/constants.png)
+
+> you can completely customize the chunk storage provider, we for example made one that is just empty where it doesnt load any chunks from disk
+> you could add an MySQLChunkStorageProvider and it could read the data from a database
+> and the same goes for worldgen, you can simply implement this interface to generate a world generator - slikey
+
+![Chunks 1](/assets/chunks-1.png)
+![Chunks 2](/assets/chunks-2.png)
+![Chunks 3](/assets/chunks-3.png)
+
+> i mean here are all the weapons defined, you tell me, obviously you will discover limitations but i think there is plenty of room to make changes - this stuff is actually hard though, there is a lot of QoL to have happen here
+
+![Weapons 1](/assets/weapons-1.png)
diff --git a/content/docs/cs-CZ/established-information/server/content-categories/art-assets.mdx b/content/docs/cs-CZ/established-information/server/content-categories/art-assets.mdx
new file mode 100644
index 00000000..39c2ed37
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/server/content-categories/art-assets.mdx
@@ -0,0 +1,123 @@
+---
+title: Modelling & Texturing / Art Assets
+description: Information about 3D Modelling, Texturing and Art Assets in Hytale.
+---
+
+# Modelling / Texture Art
+
+Hytale provides comprehensive support for 3D modeling and texture art creation, with specialized tools and workflows designed to maintain the game's distinctive visual style while empowering creators.
+
+## Current Mod Tooling
+
+### Blockbench
+
+Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
+
+* **Official support**: Used for "creating Hytale models, textures, and animations"
+* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
+* **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
+* **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
+
+## Model Constraints
+
+### Geometry Types
+
+The vast majority of models in Hytale are constrained to specific geometric primitives:
+
+**3D Elements**:
+
+* Blocks
+* Cuboids
+* Boxes
+
+**2D Elements**:
+
+* Quads
+* Rectangles
+* Planes (composed of 2 triangles)
+
+### Design Philosophy
+
+These constraints serve multiple purposes:
+
+* **Performance optimization**: Ensures efficient rendering and game performance
+* **Consistent art style**: Maintains Hytale's distinctive visual aesthetic
+* **Seamless integration**: Makes mods feel more cohesive with the base game
+
+## Pixel Density Standards
+
+Hytale uses different pixel densities for different types of content:
+
+### Standard Densities
+
+* **Blocks**: 32px density
+* **Player models**: 64px density
+* **Mobs**: Likely also 64px density
+* **Player equipment**: 64px density (weapons, cosmetics, armor, etc.)
+
+### Flexibility
+
+* **Wrong density handling**: Using incorrect density may cause assets to appear at the wrong size, but will not cause import failures
+* **No strict restrictions**: Pixel ratio, rotation, and scaling are not restricted
+* **Forgiving system**: The tools are designed to be flexible while maintaining compatibility
+
+## Hytale Asset Editor
+
+### In-Game Editor
+
+The Asset Editor is a comprehensive tool that will ship with the game:
+
+* **Ships with game**: Available to all players from launch
+* **External tool requirement**: Does not support image editing, you must use external tools for texture creation
+* **Data asset editing**: Primary editor for working with Data Assets
+* **Expanding capabilities**: Currently supports most features, though has limitations around NPCs, worldgen, and interactions that will expand over time
+
+### Particle Creation
+
+The Asset Editor includes robust particle creation tools:
+
+* **In-game creation**: Particles are created directly in-game using the Asset Editor
+* **Industry standard**: Particle logic is robust and similar to Unity/Unreal particle systems
+* **Event-driven**: Particles can be spawned on events or interactions (like opening doors)
+* **Entity attachment**: Can attach particles to entities with specific attachment points
+* **Dynamic movement**: Supports particles moving with their anchor points
+* **Time delays**: Supports time-based particle effects and delays
+
+## Materials
+
+### Optimization Focus
+
+Hytale takes a different approach to materials compared to other engines:
+
+* **Pre-optimized**: Materials are very optimized and artists cannot create custom materials
+* **Performance priority**: This constraint ensures consistent performance across all content
+* **Curated system**: Maintains visual consistency while maximizing efficiency
+
+## Best Practices
+
+### Asset Optimization
+
+Key considerations from Hytale's development team:
+
+* **Mindful resource usage**: Be conscious of how many blocks/quads you use and texture file sizes
+* **Avoid bloat**: Goal is to prevent unnecessary asset bloat that could impact performance
+* **Efficiency focus**: Balance visual quality with technical constraints
+
+### Future Documentation
+
+* **Best practice guide**: A comprehensive "best practice" guide for art and modeling will be released at some point
+* **Flexible boundaries**: Most creative goals can be achieved without breaking anything in the system
+* **Community-driven workflows**: Tools are designed to support established creative workflows in the modding community
+
+## Integration with Development Pipeline
+
+The modeling and texture art workflow integrates seamlessly with Hytale's broader development ecosystem:
+
+* **Asset Editor compatibility**: Models created in Blockbench work directly with the Hytale Asset Editor
+* **Data Asset integration**: 3D models can be configured and customized through Data Assets
+* **Visual Scripting support**: Models can be controlled and animated through Visual Scripting
+* **Java plugin extensibility**: Advanced model behaviors can be implemented through Java plugins
+* **Particle integration**: Models can have particles attached at specific points for enhanced visual effects
+
+This integrated approach ensures that 3D modeling and texture art aren't isolated creative processes, but core components of Hytale's comprehensive development environment.
diff --git a/content/docs/cs-CZ/established-information/server/content-categories/data-assets.mdx b/content/docs/cs-CZ/established-information/server/content-categories/data-assets.mdx
new file mode 100644
index 00000000..1c11ef23
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/server/content-categories/data-assets.mdx
@@ -0,0 +1,61 @@
+---
+title: Data Assets
+description: Information about data assets in Hytale and how they drive gameplay behavior and content creation.
+---
+
+# Data Assets
+
+Data Assets are JSON files which drive gameplay behavior and core content in Hytale. They provide a powerful, data-driven approach to creating and modifying game elements without needing to write code.
+
+## What Are Data Assets?
+
+Data Assets allow you to create or modify fundamental game elements through JSON configuration files:
+
+* **Blocks**: Define new block types and their properties
+* **Items**: Create custom items with unique behaviors
+* **NPCs**: Configure non-player characters and their AI
+* **World generation**: Control how the world is generated
+* **Loot tables**: Define what items drop from various sources
+
+## Comparison to Minecraft
+
+Data Assets are analogous to Minecraft's data pack JSON files, but with significantly broader scope. While Minecraft's data packs are somewhat limited, Hytale's data-driven architecture means that core game elements like blocks, items, and NPCs can all be modified through JSON files.
+
+This expanded data-driven approach gives modders much more power to customize the game without needing to dive into complex programming.
+
+## Development Tools
+
+Recognizing that JSON editing can be tedious and error-prone when done by hand, Hytale plans to provide multiple tools to make working with Data Assets more accessible:
+
+### Node Editor
+
+Hytale is developing a "Node Editor" to make Data Asset management more user-friendly:
+
+* **Visual interface**: Provides a graphical way to work with data relationships
+* **Customization focus**: Particularly helpful for customizing NPCs, interactions, and world generation
+* **Integrated workflow**: Works directly within the Hytale Asset Editor for a unified creator suite
+* **Accessibility**: Makes complex data relationships easier to understand and modify
+
+### Additional Tools
+
+Beyond the Node Editor, Hytale plans to support:
+
+* **Visual JSON generators**: Graphical interfaces for creating JSON without writing syntax
+* **Form-based editors**: Structured forms that generate the appropriate JSON automatically
+* **Multiple workflow options**: Different tools for different comfort levels and use cases
+
+## Power and Simplicity
+
+The effectiveness of Data Assets is demonstrated by their simplicity. For example, making raptors rideable in Hytale reportedly requires only 4 lines of JSON configuration - showcasing how powerful yet accessible the system is designed to be.
+
+This balance between power and accessibility is central to Hytale's modding philosophy: providing professional-grade tools that don't require programming expertise to use effectively.
+
+## Integration with Other Systems
+
+Data Assets work seamlessly with Hytale's other development approaches:
+
+* **Visual Scripting**: Can reference and manipulate data defined in Data Assets
+* **Java plugins**: Can read from and modify Data Assets for more complex behaviors
+* **Asset Editor**: Provides a unified interface for managing both visual assets and their data configurations
+
+This integration ensures that Data Assets aren't isolated configuration files, but rather a core part of Hytale's comprehensive development environment.
diff --git a/content/docs/cs-CZ/established-information/server/content-categories/plugin.mdx b/content/docs/cs-CZ/established-information/server/content-categories/plugin.mdx
new file mode 100644
index 00000000..5b585924
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/server/content-categories/plugin.mdx
@@ -0,0 +1,48 @@
+---
+title: Java Modding (Server Plugins)
+description: An introduction to what we know of Hytale's Java-based modding system as of writing this article.
+---
+
+Hytale's modding capabilities include a Java-based modding system that allows modders
+to create custom behaviors, interactions, and game mechanics. While the full details of
+this system are not publicly documented as the game is still in development and not
+released, we can summarize what is currently known about it.
+
+### Important Details of Modding in Hytale
+
+Hytale's modding goes on server side and not client side, meaning that mods/plugins are
+hosted on the server and players connect to these modded servers to experience the custom content
+without needing to install anything on their end. This approach ensures a consistent experience
+for all players on a modded server.
+
+### Overview of Java-Based Modding
+
+The server-side modding system in Hytale is based on Java, making the server plugins JAR files.
+
+We're guessing this is done so that Minecraft modders can easily transition to Hytale modding,
+as Minecraft modding is also primarily Java-based. This allows modders familiar with Java
+to leverage their existing knowledge when creating mods for Hytale.
+
+#### Singleplayer Concerns
+
+Despite the name, server plugins can also be used in singleplayer mode.
+Hytale's singleplayer mode runs a local server instance, allowing players to use server plugins
+even when playing alone. This means that mods created as server plugins can enhance the singleplayer experience as well.
+
+### Mixin System
+
+Mixins were used in Minecraft modding to directly modify the game’s code, even able to overwrite
+or redirect logic and values. An extremely powerful but somewhat brittle system which depends
+on the source code/game version staying pretty much the same.
+
+We have no official information on Mixins in Hytale. Despite that, we have reason to believe they will not
+need to be supported for the following reasons:
+
+1. For a properly designed game, 95% of Mixin use cases can be solved with a good API instead.
+   In fact, many Minecraft modding APIs simply mixin to provide the API so the developers using
+   those APIs don’t have to write the mixin themselves.
+   * This is typically replacing hardcoded values and overwriting hardcoded behaviors.
+   * Hytale should ideally make these both API or data-driven.
+2. APIs can also be much more resilient than the game version. We can have a separate API
+   version system which means the same code will not need to be modified across multiple updates
+   until the API changes in a breaking way.
diff --git a/content/docs/cs-CZ/established-information/server/content-categories/visual-scripting.mdx b/content/docs/cs-CZ/established-information/server/content-categories/visual-scripting.mdx
new file mode 100644
index 00000000..16cb0508
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/server/content-categories/visual-scripting.mdx
@@ -0,0 +1,59 @@
+---
+title: Visual Scripting
+description: An introduction to what we know of Hytale's visual scripting system as of writing this.
+---
+
+# Visual Scripting
+
+Hytale plans to support Visual Scripting as a method to make advanced logic and control flow accessible to a wider audience. This system will not be available at launch, but should be available shortly after launch.
+
+## Overview
+
+Visual Scripting in Hytale is designed to function similarly to Blueprints in Unreal Engine. It allows designers to create complex behaviors through a visual interface that matches how they think about game logic, without needing to write code directly.
+
+### Key Features
+
+* **Subset of Java functionality**: Visual Scripting can do a subset of what is possible with Java plugins
+* **Designer-friendly**: "Designers are empowered through a visual language that matches how they think about behaviors"
+* **Programmer extensible**: Programmers can extend and optimize the system by adding new visual nodes and performance-sensitive implementations
+* **Safe sharing environment**: Provides a sandboxed, safe environment for sharing logic between modders
+
+## Advantages Over Traditional Coding
+
+Visual Scripting makes writing custom logic more accessible by removing common hurdles found when developing in Java:
+
+* **No complex environment setup**: No need to worry about installing the right tools or configuring development environments
+* **Syntax-free development**: Removes the need to learn and remember programming syntax
+* **Safer sharing**: Malware in visual scripting should be virtually impossible
+* **More inclusive**: Lowers the barrier to entry for non-programmers
+
+## Relationship with Java
+
+Visual Scripting and Java plugins are designed to work in tandem:
+
+* **Java extends Visual Scripting**: Programmers can create new visual nodes using Java
+* **Performance optimization**: While Visual Scripting may not be as optimized as Java directly, programmers can implement performance-critical logic in Java and expose it as visual nodes
+* **Best of both worlds**: Allows the majority of logic to remain in the accessible Visual Scripting environment while keeping expensive operations optimized
+
+Hytale strongly recommends Visual Scripting since it is both more accessible and safer to share and download. However, staying purely in Java will still work for those who prefer it.
+
+## 3D Visual Scripting
+
+One of Hytale's unique features is bringing visual scripting directly into the 3D world:
+
+* **In-world editing**: Link levers, doors, spawners, triggers, and other elements directly inside the game
+* **Adventure map creation**: Excellent for building adventure maps and encounters without leaving Hytale
+* **Similar to DOOM SnapMap**: Provides a familiar workflow for those who have used similar systems
+* **Fully integrated**: Works seamlessly with the asset and scripting stack
+
+## No Text-Based Scripting
+
+Hytale has made a deliberate decision not to include text-based scripting languages. Their reasoning:
+
+* **False compromise**: Text-based scripting is often introduced to "help non-programmers" but still requires learning programming concepts
+* **Complexity increase**: Programmers end up juggling two languages where one is less powerful
+* **Still requires syntax**: Designers still need to learn syntax and programming concepts
+* **Less inclusive**: Doesn't truly solve the accessibility problem
+* **Fragmentation**: Avoids "fragmenting logic across multiple 'half-languages'"
+
+Instead, Hytale believes visual scripting is a better approach that truly makes game logic accessible to a wider audience while maintaining the power and flexibility needed
diff --git a/content/docs/cs-CZ/established-information/server/interface/inputs.mdx b/content/docs/cs-CZ/established-information/server/interface/inputs.mdx
new file mode 100644
index 00000000..b6b3ff3b
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/server/interface/inputs.mdx
@@ -0,0 +1,16 @@
+---
+title: Inputs
+description: Information about input methods supported in Hytale.
+---
+
+Hytale is designed to support a variety of input methods to accommodate different player preferences and platforms.
+
+## Interaction System
+
+Hytale features a robust interaction system that allows plugins to customize how keybinds are interpreted and what actions they trigger. This system is data-driven, enabling modders to create complex interactions through assets.
+
+Modders can define custom keybinds for various actions, such as using abilities or interacting with objects in the game world. The interaction system is designed to be powerful, though it may require some effort to manage the complexity of the assets involved.
+
+> You can use your own interactions to use keybinds for whatever you want. Interaction system is very powerful but we still need to work on its usability as the assets can become quite complex and hard to handle
+
+\- [slikey](https://discord.com/channels/523059903812599811/1428794280868184064/1441291391065129103)
diff --git a/content/docs/cs-CZ/established-information/server/interface/ui-customization.mdx b/content/docs/cs-CZ/established-information/server/interface/ui-customization.mdx
new file mode 100644
index 00000000..d2acbd6b
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/server/interface/ui-customization.mdx
@@ -0,0 +1,80 @@
+---
+title: UI Customization
+description: Information about UI customization in Hytale.
+---
+
+UI can be customized via **server-side** modding. Many of the UI pages shown to players are available to be modified by server owners through mods.
+
+## UI Customization in Hytale
+
+Hytale provides extensive UI customization capabilities through server-side modding, allowing server owners to modify many of the UI pages that players interact with.
+
+### Control Flow
+
+The UI system in Hytale follows a specific control flow pattern:
+
+1. Server sends UI data to the client
+2. Client renders the UI
+3. User interacts with the UI (e.g., pressing a button)
+4. Client sends the interaction event to the server
+5. Server executes the callback logic for the event
+
+This architecture means:
+
+* The client is responsible for rendering UI and sending user interactions to the server
+* The server handles all the actual logic behind user interactions
+
+<Callout type="warning" title="Possible Performance Implications">
+  <span>
+    Because the server processes all UI logic, there is an inherent latency
+    impact on UI responsiveness. Button clicks and other interactions must
+    travel to the server before taking effect, meaning network ping directly
+    affects UI responsiveness.
+  </span>
+
+  <span>
+    Additionally, since client-side modding is not supported, no modded values
+    persist on the client.
+  </span>
+</Callout>
+
+### UI Layout Assets
+
+Hytale's UI customization system works through the following structure:
+
+* **UI Layout**: Sent to the client as an asset
+* **UI Behavior**: Defined in Java code
+* **Custom Layouts**: Enables creation of bespoke UI layouts rather than repurposing existing ones (unlike inventory menu modifications in Minecraft)
+
+### UI Framework Implementations
+
+Hytale currently supports multiple UI implementations, with plans to consolidate on NoesisGUI:
+
+#### Legacy Implementation
+
+* Serves as an example of server modding capabilities
+* Uses a combination of in-game elements, UI Markup Assets, and Java mod code
+* Utilizes a legacy custom markup language
+* Will be deprecated in favor of NoesisGUI
+
+#### NoesisGUI (Primary Framework)
+
+* Uses XAML Markup Language for UI definition
+* Supports multiple languages for internationalization
+* Runs on C# bindings on the client side (not C++)
+* Represents the future direction of Hytale's UI system
+
+#### Third Framework
+
+* Currently being phased out
+* Will be replaced by NoesisGUI as part of the consolidation effort
+
+### Performance Considerations
+
+Due to the server-side nature of UI processing, there are inherent performance characteristics to consider:
+
+* **Latency Impact**: Button clicks and UI interactions must travel to the server before taking effect, meaning network ping directly affects UI responsiveness
+* **No Client Persistence**: Since client-side modding is not supported, no modded values persist on the client
+* **Optimized Architecture**: Hytale's system is designed to minimize latency through efficient communication protocols and optimized server performance, ensuring smooth interactions despite server-side processing requirements
+
+The architecture prioritizes security and consistency by centralizing UI logic on the server while maintaining responsive user experiences
diff --git a/content/docs/cs-CZ/established-information/server/server-first-dev.mdx b/content/docs/cs-CZ/established-information/server/server-first-dev.mdx
new file mode 100644
index 00000000..1ed97a61
--- /dev/null
+++ b/content/docs/cs-CZ/established-information/server/server-first-dev.mdx
@@ -0,0 +1,29 @@
+---
+title: Server-First Development
+description: Information regarding what Server-First Development means, and more.
+---
+
+Hytale is being developed with a "server-first" approach. This means that the server is considered the authoritative source of game state and logic, while the client primarily handles rendering and user input.
+
+## What does "Server-First" mean?
+
+In a server-first architecture, the server is responsible for managing the game world, enforcing rules, and processing player actions. The client connects to the server to receive updates about the game state and to send player inputs. This approach helps ensure consistency and fairness in multiplayer environments, as the server has control over the game logic.
+
+## Benefits of Server-First Development
+
+* **Consistency**: Since the server is the authoritative source, all players experience the same game state, reducing discrepancies and cheating.
+* **Scalability**: Server-first architectures can be more easily scaled to accommodate large numbers
+  of players, as the server can manage resources and distribute load effectively.
+* **Security**: By centralizing game logic on the server, it becomes more difficult for players to manipulate the game state unfairly.
+* **Easier Updates**: Updates and changes can be made on the server side without requiring players to download new client versions.
+* **Only One Version**: There won't be a version selector for the Hytale Client, meaning that server owners do not need to support multiple versions and can rely on everyone being on the latest client. This will help both server owners and modders.
+
+## Implications for Modding
+
+Modders will primarily interact with the server-side components of Hytale. This means that mods will often focus on altering game logic, rules, and behaviors that are managed by the server. Client-side modifications are not allowed (as of the information given right now).
+
+Overall, the server-first approach in Hytale aims to create a robust and fair multiplayer experience while providing modders with powerful tools to customize and enhance the game.
+
+## Conclusion
+
+The server-first development model is a key aspect of Hytale's architecture, ensuring a consistent and secure multiplayer experience. Modders should focus on server-side modifications to fully leverage the capabilities of this approach and create engaging content for players.
diff --git a/content/docs/cs-CZ/guides/ecs/entity-component-system.mdx b/content/docs/cs-CZ/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/cs-CZ/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/cs-CZ/guides/ecs/example-ecs-plugin.mdx b/content/docs/cs-CZ/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/cs-CZ/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/cs-CZ/guides/ecs/hytale-ecs-theory.mdx b/content/docs/cs-CZ/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/cs-CZ/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/cs-CZ/guides/ecs/systems.mdx b/content/docs/cs-CZ/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/cs-CZ/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/cs-CZ/guides/java-basics/00-introduction.mdx b/content/docs/cs-CZ/guides/java-basics/00-introduction.mdx
new file mode 100644
index 00000000..a03ad638
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/00-introduction.mdx
@@ -0,0 +1,52 @@
+---
+title: 00 - Introduction to Java
+description: A beginner's guide to understanding the fundamentals of Java programming for Hytale modding.
+---
+
+Welcome to your journey into Java Programming! This guide is designed to introduce you into the basics of java.
+
+## What is Java?
+
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+
+## What You'll Learn
+
+This guide is structured to take you step-by-step through:
+
+1. Java Syntax and Basics
+2. Control Flow
+3. Object-Oriented Programming
+
+We will then focus on only Hytale-specific concepts. (tbd)
+
+## Setting up your Environment
+
+Before we dive into programming, you'll need some essentials, you need to install:
+
+### Java Development Kit (JDK)
+
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+
+### Integrated Development Environment (IDE)
+
+An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
+
+* [IntelliJ IDEA](https://www.jetbrains.com/idea/)
+* [Eclipse](https://www.eclipse.org/)
+
+## How to Use This Guide
+
+1. Read each article in order - Concepts build on each other
+2. Type out the examples - Don't copy-paste; typing helps you learn
+3. Experiment - Modify examples to see what happens
+4. Practice - Each article includes exercises
+5. Be patient - Programming is a skill that takes time to develop
+
+## The Modding Mindset
+
+Modding is creative problem-solving. You'll be:
+
+* Adding new blocks, items, and creatures to Hytale
+* Changing game mechanics to create unique experiences
+* Building systems that interact with the game world
+* Sharing your creations with the community
diff --git a/content/docs/cs-CZ/guides/java-basics/01-variables.mdx b/content/docs/cs-CZ/guides/java-basics/01-variables.mdx
new file mode 100644
index 00000000..f884cc02
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/01-variables.mdx
@@ -0,0 +1,77 @@
+---
+title: 01 - Variables & Data Types
+description: An introduction to variables and data types in Java programming.
+---
+
+Variables are containers that store data in your program. Think of them as labeled boxes where you can put different types of information.
+
+## What is a Variable?
+
+A variable has three key components:
+
+1. **Type**: What kind of data it holds (e.g., integer, string, boolean)
+2. **Name**: The label you use to refer to the variable
+3. **Value**: The data it contains
+
+## Declaring/Creating Variables
+
+In Java, you must declare a variable before using it, like you'd need a box before putting something in it. The syntax is:
+
+```java
+int age; // A declaration
+age = 18; // An assignment
+
+int age = 18; // Declaration and assignment in one line, also considered an initialization
+```
+
+## Primitive Data Types
+
+You might wonder what "int" means. It's a primitive data type in Java. Java has 8 primitive data types. Here are the most important ones for modding:
+
+| Data Type | Description                   | Example                    |
+| --------- | ----------------------------- | -------------------------- |
+| int       | Integer (whole numbers)       | `int score = 100;`         |
+| double    | Decimal numbers               | `double pi = 3.14;`        |
+| boolean   | True or false values          | `boolean isActive = true;` |
+| char      | Single character              | `char grade = 'A';`        |
+| String    | Sequence of characters (text) | `String name = "Hytale";`  |
+
+## Type Conversion
+
+Sometimes you might not want a variable to stay the same type. You can convert between types:
+
+### Automatic
+
+```java
+int num = 10;
+double decimalNum = num; // 10.0 - works automatically
+```
+
+### Manual (Casting)
+
+```java
+double decimalNum = 9.78;
+int num = (int) decimalNum; // 9 - decimals are dropped
+```
+
+## Constants
+
+If you want a variable that shouldn't change, use the `final` keyword:
+
+```java
+final double PI = 3.14159;
+```
+
+**Convention**: Constants use ALL_CAPS_WITH_UNDERSCORES.
+
+## Practice
+
+It's best to practice what you just learnt - don't look above now and try to do this yourself. If you get stuck, look back up!
+
+1. Declare an integer variable named `lives` and set it to 3.
+2. Declare a double variable named `gravity` and set it to 9.81.
+3. Declare a boolean variable named `isGameOver` and set it to false.
+4. Convert the `lives` variable to a double and store it in a new variable named `livesAsDouble`.
+5. Declare a constant named `MAX_LEVEL` and set it to 100.
+
+Great! You've learned about variables and data types in Java. Now we're going to learn about operators and expressions in the next lesson.
diff --git a/content/docs/cs-CZ/guides/java-basics/02-operators.mdx b/content/docs/cs-CZ/guides/java-basics/02-operators.mdx
new file mode 100644
index 00000000..a132b1c0
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/02-operators.mdx
@@ -0,0 +1,128 @@
+---
+title: 02 - Operators and Expressions
+description: An introduction to operators and expressions in Java programming.
+---
+
+Operators are symbols that perform operations on variables and values. They're the verbs of programming - they make things happen!
+
+## Arithmetic Operators
+
+Used for mathematical calculations:
+
+```java
+int a = 10;
+int b = 5;
+
+int sum = a + b;        // Addition: 15
+int difference = a - b; // Subtraction: 5
+int product = a * b;    // Multiplication: 50
+int quotient = a / b;   // Division: 2
+int remainder = a % b;  // Modulus (remainder): 0
+```
+
+<Callout type="info" title="Division Note">
+  When dividing integers, Java performs integer division, which means it discards any decimal part. For example, `7 / 2` would result in `3`, not `3.5`.
+
+  ```java
+  int x = 7 / 2;       // 3 (not 3.5!) - Integer division
+  double y = 7.0 / 2;  // 3.5 - At least one double gives double result
+  double z = (double) 7 / 2;  // 3.5 - Casting works too
+  ```
+</Callout>
+
+### Modulus (%) - The remainder Operator
+
+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)
+```
+
+## Compound Assignment Operators
+
+These operators combine an arithmetic operation with assignment:
+
+```java
+int a = 10;
+
+a = a + 5;  // The old way
+
+a += 5;     // a = a + 5
+a -= 3;     // a = a - 3
+a *= 2;     // a = a * 2
+a /= 4;     // a = a / 4
+a %= 3;     // a = a % 3
+```
+
+## Increment and Decrement Operators
+
+Used to increase or decrease a variable's value by 1:
+
+```java
+int a = 5;
+a++; // Increment: a becomes 6
+a--; // Decrement: a becomes 5 again
+```
+
+<Callout type="info" title="Prefix vs Postfix">
+  ```java
+  int a = 5;
+  int b = a++; // b is 5, a is now 6
+  int c = ++a; // a is 7, c is now 7
+  ```
+</Callout>
+
+## Comparison Operators
+
+Used to compare two values, returning a boolean result (`true` or `false`):
+
+```java
+int a = 10;
+int b = 5;
+
+a == b // false - Equal to
+a != b // true  - Not equal to
+a > b  // true  - Greater than
+a < b  // false - Less than
+a >= b // true  - Greater than or equal to
+a <= b // false - Less than or equal to
+```
+
+## Logical Operators
+
+Used to combine multiple boolean expressions:
+
+```java
+boolean x = true;
+boolean y = false;
+
+x && y // false - Logical AND
+x || y // true  - Logical OR
+!x     // false - Logical NOT
+```
+
+### Combining Logical Operators
+
+```java
+boolean result = (a > b) && (b < 10); // true if both conditions are true
+```
+
+## String Concatenation
+
+The `+` operator can also be used to concatenate (join) strings:
+
+```java
+String greeting = "Hello, " + "world!"; // "Hello, world!"
+String name = "Alice";
+String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
+```
+
+## Operator Precedence
+
+Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+
+```java
+int result = 10 + 5 * 2; // result is 20, not 30
+```
+
+{/* practice to be added */}
diff --git a/content/docs/cs-CZ/guides/java-basics/03-control-flow-if.mdx b/content/docs/cs-CZ/guides/java-basics/03-control-flow-if.mdx
new file mode 100644
index 00000000..b9d6c479
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/03-control-flow-if.mdx
@@ -0,0 +1,128 @@
+---
+title: 03 - Control Flow If Statements
+description: Learn how to control the flow of your Java programs using if statements.
+---
+
+Programs need to make decisions. If statements let your code choose different paths based on conditions.
+
+## Basic If Statement
+
+The simplest form checks one condition;
+
+```java
+int health = 20;
+
+if (health > 10) {
+    System.out.println("You are healthy!");
+}
+```
+
+### Structure
+
+```java
+if (condition) {
+    // code to execute if condition is true
+}
+```
+
+## If-Else Statements
+
+Choose between two paths:
+
+```java
+int health = 5;
+
+if (health > 10) {
+    System.out.println("You are healthy!");
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## If-Else Else-If Chain
+
+Check multiple conditions in sequence:
+
+```java
+
+int health = 7;
+
+if (health > 15) {
+    System.out.println("You are in great shape!");
+} else if (health > 5) {
+    System.out.println("You are okay.");
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## Nested If Statements
+
+You can place if statements inside other if statements:
+
+```java
+int health = 12;
+
+if (health > 10) {
+    if (health > 15) {
+        System.out.println("You are in great shape!");
+    } else {
+        System.out.println("You are healthy!");
+    }
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## Compound Conditions
+
+You can combine multiple conditions using logical operators:
+
+```java
+
+// AND - both must be true
+int health = 12;
+boolean hasPotion = true;
+
+if (health > 10 && hasPotion) {
+    System.out.println("You are healthy and have a potion!");
+} else if (health > 10) {
+    System.out.println("You are healthy but need a potion!");
+} else {
+    System.out.println("You need healing!");
+}
+
+// OR - at least one must be true
+
+int health = 8;
+boolean hasPotion = false;
+if (health > 10 || hasPotion) {
+    System.out.println("You are either healthy or have a potion!");
+} else {
+    System.out.println("You need healing and a potion!");
+}
+
+// NOT - reverses the condition
+
+int health = 8;
+if (!(health > 10)) {
+    System.out.println("You need healing!");
+} else {
+    System.out.println("You are healthy!");
+}
+```
+
+## Ternary Operator
+
+A compact way to assign values:
+
+```java
+int health = 12;
+String status = (health > 10) ? "Healthy" : "Needs Healing";
+```
+
+### Syntax
+
+```java
+variable = (condition) ? valueIfTrue : valueIfFalse;
+```
diff --git a/content/docs/cs-CZ/guides/java-basics/04-control-flow-loops.mdx b/content/docs/cs-CZ/guides/java-basics/04-control-flow-loops.mdx
new file mode 100644
index 00000000..8ff5b509
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/04-control-flow-loops.mdx
@@ -0,0 +1,165 @@
+---
+title: 04 - Control Flow Loops
+description: Learn how to repeat code efficiently using loops in Java
+---
+
+Loops let you repeat code without writing it over and over. They're essential for processing collections, generating worlds, and updating game objects.
+
+## While Loop
+
+Repeats code while a condition is true:
+
+```java tab="Code"
+
+int countdown = 5;
+
+while (countdown > 0) {
+    System.out.println(countdown);
+    countdown--;
+}
+System.out.println("Blast off!");
+```
+
+```java tab="Output"
+5
+4
+3
+2
+1
+Blast off!
+```
+
+### Structure
+
+```java
+while (condition) {
+    // code to repeat
+}
+```
+
+<Callout type="warning" title="Infinite Loops">
+  Always make sure your loop condition will eventually become false, or your program will run forever!
+
+  ```java tab="Bad Example"
+  int x = 0;
+  while (x < 10) {
+      System.out.println("Stuck!");
+      // Forgot to increase x!
+  }
+  ```
+
+  ```java tab="Good Example"
+  int x = 0;
+  while (x < 10) {
+      System.out.println("Counting: " + x);
+      x++; // This increases x! // [!code ++]
+  }
+  ```
+</Callout>
+
+## Do-While Loop
+
+Like a while loop, but always runs at least once:
+
+```java
+int health = 0;
+
+do {
+    System.out.println("Attempting respawn...");
+    health = 100;
+} while (health <= 0);
+```
+
+## For Loop
+
+Best when you know how many times to repeat:
+
+```java tab="Code"
+for (int i = 1; i <= 5; i++) {
+    System.out.println("Level " + i);
+}
+```
+
+```java tab="Output"
+Level 1
+Level 2
+Level 3
+Level 4
+Level 5
+```
+
+### Structure
+
+```java
+for (initialization; condition; update) {
+    // code to repeat
+}
+```
+
+<Callout type="info" title="For Loop Parts">
+  ```java
+  for (int i = 0; i < 10; i++) {
+  //   ^         ^        ^
+  //   Start     Stop     Step
+  }
+  ```
+
+  * **Initialization**: int i = 0 - Runs once at the start
+  * **Condition**: i < 10 - Checked before each loop
+  * **Update**: i++ - Runs after each loop
+</Callout>
+
+## Break Statement
+
+You can exit a loop early with `break`:
+
+```java
+
+for (int i = 1; i <= 10; i++) {
+    if (i == 6) {
+        break; // Exit loop when i is 6
+    }
+    System.out.println(i);
+}
+
+```
+
+## Continue Statement
+
+Skip to the next iteration with `continue`:
+
+```java
+for (int i = 1; i <= 10; i++) {
+    if (i % 2 == 0) {
+        continue; // Skip even numbers
+    }
+    System.out.println(i); // Prints only odd numbers
+}
+```
+
+## Nested Loops
+
+You can put loops inside other loops:
+
+```java
+for (int i = 1; i <= 3; i++) {
+    for (int j = 1; j <= 2; j++) {
+        System.out.println("i: " + i + ", j: " + j);
+    }
+}
+```
+
+<Callout type="warning" title="Nested Loop Performance">
+  Be careful with nested loops! They can slow down your mod significantly.
+
+  ```java
+  // This runs 1,000,000 times!
+  for (int i = 0; i < 1000; i++) {
+      for (int j = 0; j < 1000; j++) {
+          // Code here
+      }
+  }
+  ```
+
+  Try to avoid deeply nested loops when processing large amounts of data.
+</Callout>
diff --git a/content/docs/cs-CZ/guides/java-basics/05-arrays.mdx b/content/docs/cs-CZ/guides/java-basics/05-arrays.mdx
new file mode 100644
index 00000000..b00d18fb
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/05-arrays.mdx
@@ -0,0 +1,306 @@
+---
+title: 05 - Arrays
+description: Learn how to store and manage collections of data using arrays.
+---
+
+Arrays let you store multiple values of the same type in a single variable. Think of an array as a row of boxes, each holding one item.
+
+## Creating Arrays
+
+### Method 1: Declare and Initialize Separately
+
+```java
+int[] numbers;           // Declare
+numbers = new int[5];    // Create array with 5 spaces
+```
+
+### Method 2: All at Once
+
+```java
+int[] numbers = new int[5];
+```
+
+### Method 3: With Initial Values
+
+```java
+int[] numbers = {10, 20, 30, 40, 50};
+```
+
+<Callout type="info" title="Array Size">
+  Once you create an array, its size is **fixed**. You can't add or remove elements later!
+
+  ```java
+  int[] inventory = new int[9];  // Always has exactly 9 slots
+  ```
+</Callout>
+
+## Accessing Array Elements
+
+Arrays use **index** numbers starting from **0**:
+
+```java
+String[] players = {"Alice", "Bob", "Charlie"};
+
+System.out.println(players[0]); // "Alice"
+System.out.println(players[1]); // "Bob"
+System.out.println(players[2]); // "Charlie"
+```
+
+### Visual Representation
+
+| Index | 0       | 1     | 2         |
+| ----- | ------- | ----- | --------- |
+| Value | "Alice" | "Bob" | "Charlie" |
+
+## Modifying Array Values
+
+```java
+int[] health = {100, 80, 90};
+
+health[1] = 60;  // Change Bob's health to 60
+
+System.out.println(health[0]); // 100
+System.out.println(health[1]); // 60
+System.out.println(health[2]); // 90
+```
+
+## Array Length
+
+Use `.length` to get the size of an array:
+
+```java
+int[] scores = {45, 67, 89, 92, 55};
+System.out.println(scores.length); // 5
+```
+
+<Callout type="warning" title="Length is Not a Method">
+  Notice there are no parentheses! It's `array.length`, not `array.length()`.
+</Callout>
+
+## Looping Through Arrays
+
+### Using For Loop
+
+```java
+String[] items = {"Sword", "Shield", "Potion"};
+
+for (int i = 0; i < items.length; i++) {
+    System.out.println(items[i]);
+}
+```
+
+### Using Enhanced For Loop (For-Each)
+
+```java
+String[] items = {"Sword", "Shield", "Potion"};
+
+for (String item : items) {
+    System.out.println(item);
+}
+```
+
+<Callout type="info" title="Enhanced For Loop">
+  The enhanced for loop is simpler and safer, but you can't modify the array or know the current index.
+
+  ```java
+  // When you need the index
+  for (int i = 0; i < items.length; i++) {
+      System.out.println(i + ": " + items[i]);
+  }
+
+  // When you just need the values
+  for (String item : items) {
+      System.out.println(item);
+  }
+  ```
+</Callout>
+
+## Multidimensional Arrays
+
+Arrays can hold other arrays, creating a grid:
+
+```java
+int[][] grid = {
+    {1, 2, 3},
+    {4, 5, 6},
+    {7, 8, 9}
+};
+
+System.out.println(grid[0][0]); // 1
+System.out.println(grid[1][2]); // 6
+System.out.println(grid[2][1]); // 8
+```
+
+### Visual Representation
+
+|       | 0 | 1 | 2 |
+| ----- | - | - | - |
+| **0** | 1 | 2 | 3 |
+| **1** | 4 | 5 | 6 |
+| **2** | 7 | 8 | 9 |
+
+### Looping Through 2D Arrays
+
+```java tab="Code"
+int[][] grid = {
+    {1, 2, 3},
+    {4, 5, 6}
+};
+
+for (int row = 0; row < grid.length; row++) {
+    for (int col = 0; col < grid[row].length; col++) {
+        System.out.print(grid[row][col] + " ");
+    }
+    System.out.println();
+}
+```
+
+```java tab="Output"
+1 2 3
+4 5 6
+```
+
+## Practical Examples
+
+### Player Inventory System
+
+```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");
+    }
+}
+```
+
+### Find Highest Score
+
+```java
+int[] scores = {45, 92, 67, 88, 55, 71};
+int highest = scores[0];
+
+for (int i = 1; i < scores.length; i++) {
+    if (scores[i] > highest) {
+        highest = scores[i];
+    }
+}
+
+System.out.println("Highest score: " + highest);
+```
+
+### Calculate Average
+
+```java
+double[] temperatures = {23.5, 25.0, 22.8, 24.3, 26.1};
+double sum = 0;
+
+for (double temp : temperatures) {
+    sum += temp;
+}
+
+double average = sum / temperatures.length;
+System.out.println("Average temperature: " + average);
+```
+
+### Block Grid (2D Array)
+
+```java
+String[][] terrain = new String[5][5];
+
+// Fill with grass
+for (int x = 0; x < 5; x++) {
+    for (int z = 0; z < 5; z++) {
+        terrain[x][z] = "grass";
+    }
+}
+
+// Place some stone
+terrain[2][2] = "stone";
+terrain[1][3] = "stone";
+
+// Display grid
+for (int x = 0; x < terrain.length; x++) {
+    for (int z = 0; z < terrain[x].length; z++) {
+        System.out.print(terrain[x][z] + " ");
+    }
+    System.out.println();
+}
+```
+
+## Common Array Operations
+
+### Copy an Array
+
+```java
+int[] original = {1, 2, 3, 4, 5};
+int[] copy = original.clone();
+
+// Or manually
+int[] copy2 = new int[original.length];
+for (int i = 0; i < original.length; i++) {
+    copy2[i] = original[i];
+}
+```
+
+### Search for a Value
+
+```java
+String[] items = {"Sword", "Shield", "Potion", "Bow"};
+String target = "Potion";
+int foundIndex = -1;
+
+for (int i = 0; i < items.length; i++) {
+    if (items[i].equals(target)) {
+        foundIndex = i;
+        break;
+    }
+}
+
+if (foundIndex != -1) {
+    System.out.println("Found at index: " + foundIndex);
+} else {
+    System.out.println("Not found");
+}
+```
+
+### Count Occurrences
+
+```java
+String[] blocks = {"stone", "dirt", "stone", "grass", "stone"};
+String searchFor = "stone";
+int count = 0;
+
+for (String block : blocks) {
+    if (block.equals(searchFor)) {
+        count++;
+    }
+}
+
+System.out.println(searchFor + " appears " + count + " times");
+```
+
+## Array Limitations
+
+<Callout type="warning" title="Fixed Size">
+  Arrays can't grow or shrink. If you need flexibility, you'll learn about `ArrayList` later!
+
+  ```java
+  int[] numbers = new int[5];
+  // Can't add a 6th element!
+
+  // If you need more space, create a new array
+  int[] bigger = new int[10];
+  for (int i = 0; i < numbers.length; i++) {
+      bigger[i] = numbers[i];
+  }
+  ```
+</Callout>
diff --git a/content/docs/cs-CZ/guides/java-basics/06-methods-functions.mdx b/content/docs/cs-CZ/guides/java-basics/06-methods-functions.mdx
new file mode 100644
index 00000000..e8e60761
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/06-methods-functions.mdx
@@ -0,0 +1,432 @@
+---
+title: 06 - Methods (Functions)
+description: Learn how to organize and reuse code with methods.
+---
+
+Methods are reusable blocks of code that perform specific tasks. They help you avoid repeating code and make your programs easier to understand.
+
+## What is a Method?
+
+Think of a method as a recipe. You define it once, then use it whenever you need it.
+
+```java tab="Code"
+public class Game {
+    public static void main(String[] args) {
+        greet();        // Call the method
+        greet();        // Call it again!
+    }
+    
+    // Method definition
+    public static void greet() {
+        System.out.println("Welcome to Hytale!");
+    }
+}
+```
+
+```text tab="Output"
+Welcome to Hytale!
+Welcome to Hytale!
+```
+
+## Method Structure
+
+```java
+public static void methodName() {
+//  ^      ^     ^      ^       ^
+//  |      |     |      |       |
+// access static return name  parameters
+// modifier       type
+    // Code goes here
+}
+```
+
+We'll learn what `public` and `static` mean later. For now, just use them.
+
+## Methods with Parameters
+
+Parameters let you pass data into methods:
+
+```java
+public static void greetPlayer(String name) {
+    System.out.println("Hello, " + name + "!");
+}
+
+public static void main(String[] args) {
+    greetPlayer("Alice");  // Hello, Alice!
+    greetPlayer("Bob");    // Hello, Bob!
+}
+```
+
+### Multiple Parameters
+
+```java
+public static void dealDamage(String target, int damage) {
+    System.out.println(target + " takes " + damage + " damage!");
+}
+
+public static void main(String[] args) {
+    dealDamage("Zombie", 20);    // Zombie takes 20 damage!
+    dealDamage("Skeleton", 15);  // Skeleton takes 15 damage!
+}
+```
+
+<Callout type="info" title="Parameter Order Matters">
+  When calling a method, arguments must match the parameter order:
+
+  ```java
+  public static void createItem(String name, int quantity, double price) {
+      // ...
+  }
+
+  // Correct
+  createItem("Sword", 1, 50.0);
+
+  // Wrong - Order matters!
+  createItem(1, "Sword", 50.0);  // Error!
+  ```
+</Callout>
+
+## Methods with Return Values
+
+Methods can send data back using `return`:
+
+```java
+public static int add(int a, int b) {
+    int sum = a + b;
+    return sum;
+}
+
+public static void main(String[] args) {
+    int result = add(5, 3);
+    System.out.println(result);  // 8
+}
+```
+
+The return type must match what you return:
+
+* `void` - Returns nothing
+* `int` - Returns an integer
+* `double` - Returns a decimal
+* `boolean` - Returns true/false
+* `String` - Returns text
+
+```java
+public static String getItemName() {
+    return "Diamond Sword";
+}
+
+public static boolean isPlayerAlive(int health) {
+    return health > 0;
+}
+
+public static double calculateDamage(int attack, double multiplier) {
+    return attack * multiplier;
+}
+```
+
+<Callout type="warning" title="Return Stops Execution">
+  Once a method hits `return`, it immediately exits. Code after `return` won't run!
+
+  ```java
+  public static int getValue() {
+      return 10;
+      System.out.println("This never runs!");  // Unreachable code!
+  }
+  ```
+</Callout>
+
+## Practical Examples
+
+### Health System
+
+```java tab="Code"
+public static void displayHealth(String name, int health, int maxHealth) {
+    double percentage = (health * 100.0) / maxHealth;
+    System.out.println(name + ": " + health + "/" + maxHealth + 
+                      " (" + percentage + "%)");
+}
+
+public static void main(String[] args) {
+    displayHealth("Player", 75, 100);
+    displayHealth("Boss", 450, 500);
+}
+```
+
+```text tab="Output"
+Player: 75/100 (75.0%)
+Boss: 450/500 (90.0%)
+```
+
+### Damage Calculator
+
+```java tab="Code"
+public static int calculateDamage(int baseAttack, int weaponDamage, boolean isCritical) {
+    int totalDamage = baseAttack + weaponDamage;
+    
+    if (isCritical) {
+        totalDamage *= 2;
+    }
+    
+    return totalDamage;
+}
+
+public static void main(String[] args) {
+    int damage1 = calculateDamage(10, 15, false);  // 25
+    int damage2 = calculateDamage(10, 15, true);   // 50
+    
+    System.out.println("Normal hit: " + damage1);
+    System.out.println("Critical hit: " + damage2);
+}
+```
+
+### Level Requirements
+
+```java tab="Code"
+public static int getXPForLevel(int level) {
+    return level * 100;
+}
+
+public static boolean canLevelUp(int currentXP, int currentLevel) {
+    int required = getXPForLevel(currentLevel + 1);
+    return currentXP >= required;
+}
+
+public static void main(String[] args) {
+    int playerXP = 450;
+    int playerLevel = 4;
+    
+    if (canLevelUp(playerXP, playerLevel)) {
+        System.out.println("You can level up!");
+    } else {
+        int needed = getXPForLevel(playerLevel + 1) - playerXP;
+        System.out.println("Need " + needed + " more XP");
+    }
+}
+```
+
+### Distance Calculator
+
+```java tab="Code"
+public static double calculateDistance(int x1, int y1, int x2, int y2) {
+    int dx = x2 - x1;
+    int dy = y2 - y1;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+public static boolean isInRange(int x1, int y1, int x2, int y2, double range) {
+    double distance = calculateDistance(x1, y1, x2, y2);
+    return distance <= range;
+}
+
+public static void main(String[] args) {
+    // Check if enemy is in attack range
+    if (isInRange(0, 0, 5, 5, 10.0)) {
+        System.out.println("Target in range!");
+    }
+}
+```
+
+## Method Overloading
+
+You can have multiple methods with the same name but different parameters:
+
+```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
+}
+```
+
+<Callout type="info" title="Method Overloading Rules">
+  Methods are considered different if they have:
+
+  * Different number of parameters
+  * Different types of parameters
+  * Different order of parameters
+
+  ```java
+  public static void test(int a) { }
+  public static void test(int a, int b) { }        // Different count
+  public static void test(double a) { }            // Different type
+  public static void test(String a, int b) { }     // Different types
+  public static void test(int a, String b) { }     // Different order
+
+  // Wrong - Only return type is different
+  public static int test(int a) { }
+  ```
+</Callout>
+
+## Common Patterns in Hytale Modding
+
+### Item Creation
+
+```java
+public static Item createItem(String name, int durability) {
+    Item item = new Item();
+    item.setName(name);
+    item.setDurability(durability);
+    return item;
+}
+
+public static Item createSword() {
+    return createItem("Sword", 100);
+}
+
+public static Item createPickaxe() {
+    return createItem("Pickaxe", 150);
+}
+```
+
+### Block Placement Validation
+
+```java
+public static boolean canPlaceBlock(int x, int y, int z) {
+    // Check if position is valid
+    if (y < 0 || y > 255) {
+        return false;
+    }
+    
+    // Check if block already exists
+    if (isBlockAt(x, y, z)) {
+        return false;
+    }
+    
+    return true;
+}
+
+public static void placeBlock(int x, int y, int z, String type) {
+    if (canPlaceBlock(x, y, z)) {
+        // Place the block
+        System.out.println("Placed " + type + " at (" + x + ", " + y + ", " + z + ")");
+    } else {
+        System.out.println("Cannot place block there!");
+    }
+}
+```
+
+### Player State Checks
+
+```java
+public static boolean isLowHealth(int health, int maxHealth) {
+    return (health * 100.0 / maxHealth) < 25;
+}
+
+public static String getHealthStatus(int health, int maxHealth) {
+    double percentage = (health * 100.0) / maxHealth;
+    
+    if (percentage >= 75) {
+        return "Healthy";
+    } else if (percentage >= 50) {
+        return "Injured";
+    } else if (percentage >= 25) {
+        return "Critical";
+    } else {
+        return "Near Death";
+    }
+}
+```
+
+## Best Practices
+
+<Callout type="info" title="Method Naming">
+  Use descriptive verb-based names that explain what the method does:
+
+  ```java
+  // Good
+  public static void calculateDamage() { }
+  public static boolean isPlayerAlive() { }
+  public static String getItemName() { }
+  public static void displayInventory() { }
+
+  // Bad
+  public static void dmg() { }        // Too short
+  public static void method1() { }    // Not descriptive
+  public static void stuff() { }      // Too vague
+  ```
+</Callout>
+
+## Practice Exercises
+
+1. **Temperature Converter**: Write methods to convert:
+   * Celsius to Fahrenheit: `(C × 9/5) + 32`
+   * Fahrenheit to Celsius: `(F - 32) × 5/9`
+
+2. **Circle Calculator**: Create methods that calculate:
+   * Area: `π × radius²`
+   * Circumference: `2 × π × radius`
+   * Use `Math.PI` for π
+
+3. **Item Durability**: Write these methods:
+   * `damageItem(int current, int damage)` - returns new durability
+   * `isBroken(int durability)` - returns true if durability is less than or equal to 0
+   * `repairItem(int current, int max)` - returns max durability
+
+4. **Password Validator**: Create a method that checks if a password is valid:
+   * At least 8 characters long
+   * Contains at least one number
+   * Returns true if valid, false otherwise
+
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
+## Common Mistakes
+
+```java
+// Wrong - Forgetting return statement
+public static int getValue() {
+    int x = 10;
+    // Forgot to return!
+} !
+
+// Correct
+public static int getValue() {
+    int x = 10;
+    return x;
+}
+
+// Wrong - Wrong return type
+public static int getText() {
+    return "Hello";  // Error! Should return int, not String
+}
+
+// Correct
+public static String getText() {
+    return "Hello";
+}
+
+// Wrong - Not calling the method
+public static void main(String[] args) {
+    greet;  // Error! Missing ()
+}
+
+// Correct
+public static void main(String[] args) {
+    greet();
+}
+```
+
+---
diff --git a/content/docs/cs-CZ/guides/java-basics/07-introduction-oop.mdx b/content/docs/cs-CZ/guides/java-basics/07-introduction-oop.mdx
new file mode 100644
index 00000000..058b7e5e
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/07-introduction-oop.mdx
@@ -0,0 +1,378 @@
+---
+title: 07 - Introduction to Object-Oriented Programming
+description: Learn the fundamentals of classes and objects in Java.
+---
+
+Object-Oriented Programming (OOP) is the foundation of Java and Hytale modding. Instead of just having variables and methods floating around, we organize them into **classes** and **objects**.
+
+## What is a Class?
+
+A class is a blueprint for creating objects. Think of it like a recipe or a template.
+
+```java
+public class Player {
+    // Properties (data)
+    String name;
+    int health;
+    int level;
+    
+    // Behavior (methods)
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+    }
+}
+```
+
+## What is an Object?
+
+An object is an instance created from a class. If a class is a blueprint, an object is the actual thing built from that blueprint.
+
+```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!
+    }
+}
+```
+
+<Callout type="info" title="Class vs Object">
+  **Class** = Blueprint (the idea of a player)
+  **Object** = Actual thing (Alice, Bob, specific players)
+
+  One class can create many objects, just like one recipe can make many cakes!
+</Callout>
+
+## Creating a Simple Class
+
+Let's create a `Sword` class for Hytale:
+
+```java
+public class Sword {
+    // Properties
+    String name;
+    int damage;
+    int durability;
+    
+    // Method to use the sword
+    public void attack(String target) {
+        System.out.println("Attacking " + target + " for " + damage + " damage!");
+        durability -= 1;
+        
+        if (durability <= 0) {
+            System.out.println(name + " broke!");
+        }
+    }
+    
+    // Method to display info
+    public void displayInfo() {
+        System.out.println("Weapon: " + name);
+        System.out.println("Damage: " + damage);
+        System.out.println("Durability: " + durability);
+    }
+}
+```
+
+Using the class:
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Sword sword = new Sword();
+        sword.name = "Iron Sword";
+        sword.damage = 15;
+        sword.durability = 3;
+        
+        sword.displayInfo();
+        sword.attack("Zombie");
+        sword.attack("Skeleton");
+        sword.attack("Spider");  // This will break the sword
+    }
+}
+```
+
+## Constructors
+
+Instead of setting properties one by one, use a **constructor** to initialize objects:
+
+```java
+public class Sword {
+    String name;
+    int damage;
+    int durability;
+    
+    // Constructor
+    public Sword(String weaponName, int weaponDamage, int weaponDurability) {
+        name = weaponName;
+        damage = weaponDamage;
+        durability = weaponDurability;
+    }
+    
+    public void attack(String target) {
+        System.out.println("Attacking " + target + " for " + damage + " damage!");
+        durability--;
+    }
+}
+```
+
+Now creating swords is easier:
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        // Much cleaner!
+        Sword ironSword = new Sword("Iron Sword", 15, 100);
+        Sword diamondSword = new Sword("Diamond Sword", 25, 200);
+        
+        ironSword.attack("Zombie");
+        diamondSword.attack("Boss");
+    }
+}
+```
+
+<Callout type="info" title="Constructor Rules">
+  * Same name as the class
+  * No return type (not even `void`)
+  * Called automatically when you use `new`
+  * Can have multiple constructors (overloading)
+
+  ```java
+  public class Item {
+      String name;
+      int value;
+      
+      // Constructor with all parameters
+      public Item(String name, int value) {
+          this.name = name;
+          this.value = value;
+      }
+      
+      // Constructor with just name
+      public Item(String name) {
+          this.name = name;
+          this.value = 0;  // Default value
+      }
+  }
+  ```
+</Callout>
+
+## The `this` Keyword
+
+`this` refers to the current object. Use it to clarify when parameter names match property names:
+
+```java
+public class Player {
+    String name;
+    int health;
+    
+    public Player(String name, int health) {
+        this.name = name;      // this.name = the property
+        this.health = health;  // name = the parameter
+    }
+}
+```
+
+Without `this`, Java gets confused:
+
+```java
+public Player(String name, int health) {
+    name = name;      // ❌ Which name? Ambiguous!
+    health = health;  // ❌ Which health? Ambiguous!
+}
+```
+
+## Practical Examples
+
+### Item Class
+
+```java
+public class Item {
+    String name;
+    String type;
+    int quantity;
+    double weight;
+    
+    public Item(String name, String type, int quantity, double weight) {
+        this.name = name;
+        this.type = type;
+        this.quantity = quantity;
+        this.weight = weight;
+    }
+    
+    public void use() {
+        if (quantity > 0) {
+            quantity--;
+            System.out.println("Used " + name + ". Remaining: " + quantity);
+        } else {
+            System.out.println("No more " + name + " left!");
+        }
+    }
+    
+    public double getTotalWeight() {
+        return weight * quantity;
+    }
+}
+```
+
+```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
+    }
+}
+```
+
+### Monster Class
+
+```java
+public class Monster {
+    String name;
+    int health;
+    int attack;
+    boolean isHostile;
+    
+    public Monster(String name, int health, int attack, boolean isHostile) {
+        this.name = name;
+        this.health = health;
+        this.attack = attack;
+        this.isHostile = isHostile;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+        
+        if (health <= 0) {
+            System.out.println(name + " was defeated!");
+        } else {
+            System.out.println(name + " has " + health + " health left.");
+        }
+    }
+    
+    public int attackPlayer() {
+        if (isHostile && health > 0) {
+            System.out.println(name + " attacks for " + attack + " damage!");
+            return attack;
+        }
+        return 0;
+    }
+    
+    public boolean isAlive() {
+        return health > 0;
+    }
+}
+```
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Monster zombie = new Monster("Zombie", 50, 10, true);
+        Monster chicken = new Monster("Chicken", 10, 0, false);
+        
+        zombie.takeDamage(20);        // Zombie took 20 damage!
+        int damage = zombie.attackPlayer();  // Zombie attacks for 10 damage!
+        
+        if (zombie.isAlive()) {
+            System.out.println("Monster is still alive!");
+        }
+    }
+}
+```
+
+### Block Class
+
+```java
+public class Block {
+    String type;
+    int x, y, z;
+    boolean isSolid;
+    int hardness;
+    
+    public Block(String type, int x, int y, int z, boolean isSolid, int hardness) {
+        this.type = type;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.isSolid = isSolid;
+        this.hardness = hardness;
+    }
+    
+    public void breakBlock() {
+        System.out.println("Breaking " + type + " block at (" + x + ", " + y + ", " + z + ")");
+        System.out.println("Hardness: " + hardness);
+    }
+    
+    public String getPosition() {
+        return "(" + x + ", " + y + ", " + z + ")";
+    }
+    
+    public boolean canWalkThrough() {
+        return !isSolid;
+    }
+}
+```
+
+## Access Modifiers (Preview)
+
+You've seen `public` - it means "anyone can access this". We'll learn more about access control later, but here's a preview:
+
+```java
+public class Example {
+    public String publicVar;      // Anyone can access
+    private String privateVar;    // Only this class can access
+    /* (no modifier) */ String defaultVar; // Package access
+}
+```
+
+For now, use `public` for everything. We'll learn when to use `private` in the next article.
+
+<Callout type="info" title="Why Use Classes?">
+  Classes help you:
+
+  * **Organize** related data and methods together
+  * **Reuse** code easily (create many objects from one class)
+  * **Model** real-world things (players, items, monsters)
+  * **Maintain** code (changes in one place affect all objects)
+
+  Without classes, managing 100 players would require 100 separate variables for each property. With classes, it's just 100 Player objects!
+</Callout>
+
+## Practice Exercises
+
+1. **Create a `Potion` Class**:
+   * Properties: name, healAmount, uses
+   * Constructor to set all properties
+   * Method `drink()` that heals and decreases uses
+   * Method `isEmpty()` that returns true if uses less than or equal to 0
+
+2. **Create a `Chest` Class**:
+   * Properties: isLocked, itemCount, capacity
+   * Constructor
+   * Method `addItem()` that checks capacity
+   * Method `unlock()` that sets isLocked to false
+   * Method `isFull()` that checks if itemCount >= capacity
+
+3. **Create a `Villager` Class**:
+   * Properties: name, profession, tradeCount
+   * Constructor
+   * Method `greet()` that prints a greeting
+   * Method `trade()` that increases tradeCount
+   * Method `getInfo()` that displays all properties
+
+4. **Create Multiple Objects**: Using any class you made, create 3 different objects and test all their methods.
diff --git a/content/docs/cs-CZ/guides/java-basics/08-access-modifiers.mdx b/content/docs/cs-CZ/guides/java-basics/08-access-modifiers.mdx
new file mode 100644
index 00000000..af560932
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/08-access-modifiers.mdx
@@ -0,0 +1,595 @@
+---
+title: 08 - Encapsulation and Access Modifiers
+description: Learn how to protect and control access to your class data.
+---
+
+Encapsulation is about hiding the internal details of a class and controlling how its data is accessed and modified. This prevents bugs and makes your code more maintainable.
+
+## The Problem Without Encapsulation
+
+```java
+public class Player {
+    public String name;
+    public int health;
+    public int maxHealth;
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Player player = new Player();
+        player.health = 100;
+        player.maxHealth = 100;
+        
+        // Oops! Someone can break the rules
+        player.health = 500;      // Health over maximum!
+        player.health = -50;      // Negative health!
+        player.name = "";         // Empty name!
+    }
+}
+```
+
+Without protection, anyone can set invalid values!
+
+## Access Modifiers
+
+Java has keywords that control who can access your class members:
+
+| Modifier    | Class | Package | Subclass | World |
+| ----------- | ----- | ------- | -------- | ----- |
+| `public`    | ✓     | ✓       | ✓        | ✓     |
+| `protected` | ✓     | ✓       | ✓        | ✗     |
+| (none)      | ✓     | ✓       | ✗        | ✗     |
+| `private`   | ✓     | ✗       | ✗        | ✗     |
+
+**For now, focus on:**
+
+* `public` - Anyone can access
+* `private` - Only this class can access
+
+## Making Properties Private
+
+```java
+public class Player {
+    private String name;
+    private int health;
+    private int maxHealth;
+    
+    public Player(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+}
+```
+
+Now you can't access properties directly:
+
+```java
+Player player = new Player("Alice", 100);
+player.health = 500;  // ❌ Error! health is private
+```
+
+## Getters and Setters
+
+To access private properties, create **getter** and **setter** methods:
+
+```java
+public class Player {
+    private String name;
+    private int health;
+    private int maxHealth;
+    
+    public Player(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+    
+    // Getter - returns the value
+    public int getHealth() {
+        return health;
+    }
+    
+    // Setter - sets the value with validation
+    public void setHealth(int health) {
+        if (health < 0) {
+            this.health = 0;
+        } else if (health > maxHealth) {
+            this.health = maxHealth;
+        } else {
+            this.health = health;
+        }
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public int getMaxHealth() {
+        return maxHealth;
+    }
+}
+```
+
+Now you can safely interact with the object:
+
+```java
+Player player = new Player("Alice", 100);
+
+player.setHealth(150);  // Automatically capped at 100
+System.out.println(player.getHealth());  // 100
+
+player.setHealth(-20);  // Automatically set to 0
+System.out.println(player.getHealth());  // 0
+```
+
+<Callout type="info" title="Getter and Setter Naming">
+  Follow Java naming conventions:
+
+  * **Getter**: `get` + property name (capitalized)
+  * **Setter**: `set` + property name (capitalized)
+  * **Boolean**: `is` + property name (capitalized)
+
+  ```java
+  private int health;
+  public int getHealth() { }
+  public void setHealth(int health) { }
+
+  private boolean alive;
+  public boolean isAlive() { }
+  public void setAlive(boolean alive) { }
+
+  private String name;
+  public String getName() { }
+  public void setName(String name) { }
+  ```
+</Callout>
+
+## Benefits of Encapsulation
+
+### 1. Validation
+
+```java
+public class Item {
+    private int durability;
+    private int maxDurability;
+    
+    public void setDurability(int durability) {
+        if (durability < 0) {
+            this.durability = 0;
+        } else if (durability > maxDurability) {
+            this.durability = maxDurability;
+        } else {
+            this.durability = durability;
+        }
+    }
+    
+    public boolean isBroken() {
+        return durability <= 0;
+    }
+}
+```
+
+### 2. Read-Only Properties
+
+Sometimes you don't want a setter:
+
+```java
+public class Monster {
+    private String id;  // Should never change
+    private int health;
+    
+    public Monster(String id, int health) {
+        this.id = id;
+        this.health = health;
+    }
+    
+    // Getter only - no setter!
+    public String getId() {
+        return id;
+    }
+    
+    public int getHealth() {
+        return health;
+    }
+    
+    public void setHealth(int health) {
+        this.health = health;
+    }
+}
+```
+
+### 3. Computed Properties
+
+Getters don't have to return a field directly:
+
+```java
+public class Player {
+    private int health;
+    private int maxHealth;
+    
+    public int getHealth() {
+        return health;
+    }
+    
+    // Computed property
+    public double getHealthPercentage() {
+        return (health * 100.0) / maxHealth;
+    }
+    
+    // Computed property
+    public boolean isLowHealth() {
+        return getHealthPercentage() < 25;
+    }
+}
+```
+
+## Practical Examples
+
+### Item with Durability
+
+```java
+public class Tool {
+    private String name;
+    private int durability;
+    private int maxDurability;
+    private boolean broken;
+    
+    public Tool(String name, int maxDurability) {
+        this.name = name;
+        this.durability = maxDurability;
+        this.maxDurability = maxDurability;
+        this.broken = false;
+    }
+    
+    public void use() {
+        if (broken) {
+            System.out.println(name + " is broken!");
+            return;
+        }
+        
+        durability--;
+        System.out.println(name + " used. Durability: " + durability);
+        
+        if (durability <= 0) {
+            broken = true;
+            System.out.println(name + " broke!");
+        }
+    }
+    
+    public void repair() {
+        durability = maxDurability;
+        broken = false;
+        System.out.println(name + " repaired!");
+    }
+    
+    // Getters
+    public String getName() {
+        return name;
+    }
+    
+    public int getDurability() {
+        return durability;
+    }
+    
+    public boolean isBroken() {
+        return broken;
+    }
+    
+    public double getDurabilityPercentage() {
+        return (durability * 100.0) / maxDurability;
+    }
+}
+```
+
+### Bank Account Example
+
+```java
+public class PlayerWallet {
+    private int gold;
+    private int silver;
+    
+    public PlayerWallet() {
+        this.gold = 0;
+        this.silver = 0;
+    }
+    
+    public void addGold(int amount) {
+        if (amount > 0) {
+            gold += amount;
+            System.out.println("Added " + amount + " gold");
+        }
+    }
+    
+    public boolean spendGold(int amount) {
+        if (amount > gold) {
+            System.out.println("Not enough gold!");
+            return false;
+        }
+        
+        gold -= amount;
+        System.out.println("Spent " + amount + " gold");
+        return true;
+    }
+    
+    public int getGold() {
+        return gold;
+    }
+    
+    public int getTotalValue() {
+        // 1 gold = 100 silver
+        return gold * 100 + silver;
+    }
+}
+```
+
+### Protected Block System
+
+```java
+public class ProtectedBlock {
+    private int x, y, z;
+    private String type;
+    private String owner;
+    private boolean locked;
+    
+    public ProtectedBlock(int x, int y, int z, String type, String owner) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.type = type;
+        this.owner = owner;
+        this.locked = true;
+    }
+    
+    public boolean canBreak(String playerName) {
+        if (!locked) {
+            return true;
+        }
+        
+        return playerName.equals(owner);
+    }
+    
+    public void unlock(String playerName) {
+        if (playerName.equals(owner)) {
+            locked = false;
+            System.out.println("Block unlocked");
+        } else {
+            System.out.println("You don't own this block!");
+        }
+    }
+    
+    // Getters only - position and owner shouldn't change
+    public int getX() {
+        return x;
+    }
+    
+    public int getY() {
+        return y;
+    }
+    
+    public int getZ() {
+        return z;
+    }
+    
+    public String getOwner() {
+        return owner;
+    }
+    
+    public boolean isLocked() {
+        return locked;
+    }
+}
+```
+
+## When to Use Private vs Public
+
+<Callout type="info" title="General Rules">
+  **Make it private by default!** Only make things public if they need to be accessed from outside.
+
+  **Private:**
+
+  * Internal data (health, position, inventory)
+  * Helper methods used only within the class
+  * Anything that needs validation
+
+  **Public:**
+
+  * Methods that define the class's behavior
+  * Constructor
+  * Methods other classes need to call
+
+  ```java
+  public class Example {
+      // Private - internal data
+      private int internalCounter;
+      private String secretKey;
+      
+      // Public - part of the interface
+      public void doSomething() {
+          // Uses private helper method
+          validateData();
+      }
+      
+      // Private - internal helper
+      private void validateData() {
+          // ...
+      }
+  }
+  ```
+</Callout>
+
+## The `final` Keyword
+
+`final` means a variable can't be changed after it's set:
+
+```java
+public class Player {
+    private final String id;  // Can't change after creation
+    private String name;      // Can change
+    private int health;       // Can change
+    
+    public Player(String id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+    
+    public String getId() {
+        return id;
+    }
+    
+    // No setId() - it's final!
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+```
+
+## The `static` Keyword
+
+### Static Members
+
+A class can define two kinds of members:
+
+* **Instance members** — owned by each object (each instance has its own copy).
+
+* **Static members** — owned by the class (one shared copy for the entire type).
+
+Put simply: instance members belong to objects; static members belong to the class itself and are shared by all objects of that type.
+
+#### Declaration
+
+```java
+    /* (access modifier) */ static ... memberName; 
+```
+
+#### Example
+
+```java
+class Data {
+    public int x; // Instanced member
+    public static int y = 1000; // Static member
+
+    // Instanced member:
+    // can access to both static and non-static members
+    public void foo() {
+        x = 100; // OK - same as this.x = 100;
+        y = 100; // OK - same as Data.y = 200;
+    }
+
+    // Static member:
+    // cannot access to non-static variables
+    public static void bar() {
+        x = 100; // Error: non-static variable x cannot be renference from a static context
+        y = 100; // OK
+    }
+}
+```
+
+#### Accessing static members
+
+```java
+Data data = new Data();
+data.x = 1000; // OK
+
+data.y = 1000; // OK-ish - not really suggested; it's better to use Data.y
+Data.y = 1000; // OK - best practice
+
+Data.x = 1000; // Error: cannot access instanced variables in a static context
+```
+
+### Static Fields
+
+A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+
+It is declared as following:
+
+```java
+/* (access modifier) (optional) */ static /* final/volatile (optional) */ fieldName;
+```
+
+Let's take the same Data class example and add this constructor:
+
+```java
+public Data() {
+    y++; // remember that's the same as Data.y++;
+}
+```
+
+```java
+// Every instance of Data will have a private copy of the instanced member x
+// However it will point to the same location in memory for the member y
+Data d1 = new Data(); // y = 1001
+d1.x = 5;
+Data d2 = new Data(); // y = 1002
+d2.x = 25;
+Data d3 = new Data(); // y = 1003
+// ... and so on
+```
+
+### Static Methods
+
+Static methods essentially represent a function member of a certain class type
+
+From the Data class remember the function (instanced method) `foo` and (static method) `bar`
+
+One can access those methods via:
+
+```java
+Data d1 = new Data();
+
+d1.foo(); // Instanced method: Accessible ONLY by an object
+
+Data.bar(); // Static method: accessible without an object
+```
+
+### Static Initializer
+
+Use a *static initializer* block to run initialization logic when the class is first loaded:
+
+```java
+class OtherData {
+    private static int a = 12;
+    private static int b;
+    private static String msg;
+
+    static {
+        msg = "Initialization..."
+        System.out.println(msg);
+        b = 4;
+        // ... complex initialization that can't be done in a single expression
+    }
+}
+```
+
+## Practice Exercises
+
+1. **Create a `BankAccount` Class**:
+   * Private properties: accountNumber, balance
+   * Constructor to set account number
+   * Methods: deposit(), withdraw(), getBalance()
+   * Validation: can't withdraw more than balance
+   * Account number should be read-only
+
+2. **Create a `Door` Class**:
+   * Private properties: isLocked, keyCode
+   * Constructor to set the key code
+   * Methods: lock(), unlock(String code), isLocked()
+   * unlock() only works with correct code
+   * Code should be private (don't expose it!)
+
+3. **Create a `PlayerStats` Class**:
+   * Private properties: strength, defense, speed
+   * Constructor to set all stats
+   * Getters for all stats
+   * Method: getPowerLevel() that returns strength + defense + speed
+   * Stats can't be negative or over 100
+
+4. **Refactor a Class**: Take one of your classes from the previous lesson and add proper encapsulation:
+   * Make all properties private
+   * Add appropriate getters and setters
+   * Add validation where needed
diff --git a/content/docs/cs-CZ/guides/java-basics/09-string.mdx b/content/docs/cs-CZ/guides/java-basics/09-string.mdx
new file mode 100644
index 00000000..a374811b
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/09-string.mdx
@@ -0,0 +1,493 @@
+---
+title: 09 - Working with Strings
+description: Master text manipulation and string operations in Java.
+---
+
+Strings are one of the most commonly used types in Java. They're essential for handling player names, chat messages, item descriptions, and like everything you see.
+
+## String Basics
+
+Strings are objects that store text:
+
+```java
+String name = "Simon";
+String message = "Welcome to Hytale!";
+String empty = "";
+```
+
+<Callout type="warning" title="Strings are Immutable">
+  Once created, a String **cannot be changed**. Methods that seem to modify a string actually create a new one!
+
+  ```java
+  String text = "Hello";
+  text.toUpperCase();           // Creates "HELLO" but doesn't save it
+  System.out.println(text);     // Still "Hello"
+
+  String upper = text.toUpperCase();  // ✓ Save the result
+  System.out.println(upper);          // "HELLO"
+  ```
+</Callout>
+
+## String Methods
+
+### Length
+
+```java
+String name = "Alice";
+int length = name.length();
+System.out.println(length);  // 5
+```
+
+### Changing Case
+
+```java
+String text = "Hello World";
+String upper = text.toUpperCase();  // "HELLO WORLD"
+String lower = text.toLowerCase();  // "hello world"
+```
+
+### Checking Contents
+
+```java
+String message = "Welcome to Hytale";
+
+boolean hasHytale = message.contains("Hytale");  // true
+boolean hasMinecraft = message.contains("Minecraft");  // false
+
+boolean starts = message.startsWith("Welcome");  // true
+boolean ends = message.endsWith("Hytale");  // true
+```
+
+### Extracting Parts
+
+```java
+String text = "Hello World";
+
+char first = text.charAt(0);      // 'H'
+char last = text.charAt(10);      // 'd'
+
+String sub1 = text.substring(0, 5);   // "Hello"
+String sub2 = text.substring(6);      // "World"
+```
+
+<Callout type="info" title="Substring Indices">
+  `substring(start, end)` includes `start` but excludes `end`:
+
+  ```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)
+  ```
+</Callout>
+
+### Replacing Text
+
+```java
+String text = "I love Minecraft";
+String replaced = text.replace("Minecraft", "Hytale");
+System.out.println(replaced);  // "I love Hytale"
+
+String noSpaces = "Hello World".replace(" ", "");
+System.out.println(noSpaces);  // "HelloWorld"
+```
+
+### Trimming Whitespace
+
+```java
+String messy = "  Hello World  ";
+String clean = messy.trim();
+System.out.println(clean);  // "Hello World" (no spaces at ends)
+```
+
+### Splitting Strings
+
+```java
+String command = "give player sword 5";
+String[] parts = command.split(" ");
+
+System.out.println(parts[0]);  // "give"
+System.out.println(parts[1]);  // "player"
+System.out.println(parts[2]);  // "sword"
+System.out.println(parts[3]);  // "5"
+```
+
+## String Comparison
+
+<Callout type="warning" title="Never Use == for Strings">
+  Always use `.equals()` to compare string contents!
+
+  ```java
+  String name1 = "Steve";
+  String name2 = "Steve";
+
+  // Wrong - Compares object references
+  if (name1 == name2) {
+      System.out.println("Same");
+  }
+
+  // Correct - Compares actual text
+  if (name1.equals(name2)) {
+      System.out.println("Same");
+  }
+
+  // Ignore case when comparing
+  if (name1.equalsIgnoreCase("steve")) {
+      System.out.println("Same (ignoring case)");
+  }
+  ```
+</Callout>
+
+### Comparing Order
+
+```java
+String a = "Apple";
+String b = "Banana";
+
+int result = a.compareTo(b);
+// result < 0 if a comes before b
+// result == 0 if a equals b
+// result > 0 if a comes after b
+
+if (a.compareTo(b) < 0) {
+    System.out.println(a + " comes before " + b);
+}
+```
+
+## String Concatenation
+
+### Using + Operator
+
+```java
+String first = "Hello";
+String second = "World";
+String combined = first + " " + second;  // "Hello World"
+
+int score = 100;
+String message = "Score: " + score;  // "Score: 100"
+```
+
+### Using concat()
+
+```java
+String result = "Hello".concat(" World");  // "Hello World"
+```
+
+### Building Long Strings
+
+For many concatenations, use `StringBuilder`:
+
+```java
+StringBuilder builder = new StringBuilder();
+builder.append("Player: ");
+builder.append("Alice");
+builder.append(", Level: ");
+builder.append(10);
+builder.append(", Health: ");
+builder.append(100);
+
+String result = builder.toString();
+System.out.println(result);
+// "Player: Alice, Level: 10, Health: 100"
+```
+
+<Callout type="info" title="Why StringBuilder?">
+  Regular concatenation creates many temporary strings:
+
+  ```java
+  // Inefficient - Creates many temporary strings
+  String result = "";
+  for (int i = 0; i < 1000; i++) {
+      result = result + i;  // Creates 1000 temporary strings!
+  }
+
+  // Efficient - StringBuilder is mutable
+  StringBuilder sb = new StringBuilder();
+  for (int i = 0; i < 1000; i++) {
+      sb.append(i);  // Modifies one object
+  }
+  String result = sb.toString();
+  ```
+
+  Use `StringBuilder` when building strings in loops!
+</Callout>
+
+## Practical Examples
+
+### Parse Player Command
+
+```java
+public class CommandParser {
+    public static void parseCommand(String command) {
+        // "/give Steve diamond_sword 1"
+        String[] parts = command.split(" ");
+        
+        String action = parts[0].replace("/", "");  // "give"
+        String player = parts[1];                   // "Steve"
+        String item = parts[2];                     // "diamond_sword"
+        int amount = Integer.parseInt(parts[3]);    // 1
+        
+        System.out.println("Action: " + action);
+        System.out.println("Player: " + player);
+        System.out.println("Item: " + item);
+        System.out.println("Amount: " + amount);
+    }
+    
+    public static void main(String[] args) {
+        parseCommand("/give Steve diamond_sword 1");
+    }
+}
+```
+
+### Format Player Display Name
+
+```java
+public class PlayerFormatter {
+    public static String formatName(String name, int level, String rank) {
+        StringBuilder formatted = new StringBuilder();
+        
+        if (rank != null && !rank.isEmpty()) {
+            formatted.append("[").append(rank).append("] ");
+        }
+        
+        formatted.append(name);
+        formatted.append(" (Lv. ").append(level).append(")");
+        
+        return formatted.toString();
+    }
+    
+    public static void main(String[] args) {
+        String display1 = formatName("Alice", 10, "VIP");
+        System.out.println(display1);  // "[VIP] Alice (Lv. 10)"
+        
+        String display2 = formatName("Bob", 5, null);
+        System.out.println(display2);  // "Bob (Lv. 5)"
+    }
+}
+```
+
+### Validate Username
+
+```java
+public class UsernameValidator {
+    public static boolean isValid(String username) {
+        // Rules: 3-16 characters, letters and numbers only
+        
+        if (username == null || username.isEmpty()) {
+            return false;
+        }
+        
+        username = username.trim();
+        
+        if (username.length() < 3 || username.length() > 16) {
+            return false;
+        }
+        
+        for (int i = 0; i < username.length(); i++) {
+            char c = username.charAt(i);
+            if (!Character.isLetterOrDigit(c)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+    
+    public static void main(String[] args) {
+        System.out.println(isValid("Steve"));      // true
+        System.out.println(isValid("Player_123")); // false (has underscore)
+        System.out.println(isValid("ab"));         // false (too short)
+        System.out.println(isValid(""));           // false (empty)
+    }
+}
+```
+
+### Item Description Builder
+
+```java
+public class ItemDescription {
+    public static String buildDescription(String name, String rarity, 
+                                         int damage, int durability) {
+        StringBuilder desc = new StringBuilder();
+        
+        // Title with rarity color code
+        desc.append(getRarityColor(rarity));
+        desc.append(name);
+        desc.append("\n");
+        
+        // Stats
+        desc.append("Damage: ").append(damage).append("\n");
+        desc.append("Durability: ").append(durability).append("/");
+        desc.append(durability).append("\n");
+        desc.append("Rarity: ").append(rarity);
+        
+        return desc.toString();
+    }
+    
+    private static String getRarityColor(String rarity) {
+        switch (rarity.toLowerCase()) {
+            case "legendary": return "§6";  // Gold
+            case "epic": return "§5";       // Purple
+            case "rare": return "§9";       // Blue
+            case "common": return "§f";     // White
+            default: return "§7";           // Gray
+        }
+    }
+    
+    public static void main(String[] args) {
+        String desc = buildDescription("Excalibur", "Legendary", 50, 1000);
+        System.out.println(desc);
+    }
+}
+```
+
+### Chat Message Filter
+
+```java
+public class ChatFilter {
+    private static String[] bannedWords = {"badword1", "badword2"};
+    
+    public static String filterMessage(String message) {
+        String filtered = message.toLowerCase();
+        
+        for (String word : bannedWords) {
+            if (filtered.contains(word)) {
+                String replacement = "*".repeat(word.length());
+                filtered = filtered.replace(word, replacement);
+            }
+        }
+        
+        return filtered;
+    }
+    
+    public static void main(String[] args) {
+        String message = "This is a badword1 test";
+        String clean = filterMessage(message);
+        System.out.println(clean);  // "this is a ******** test"
+    }
+}
+```
+
+## String Formatting
+
+### Using String.format()
+
+```java
+String name = "Alice";
+int level = 10;
+double health = 85.5;
+
+String formatted = String.format("%s is level %d with %.1f%% health", 
+                                 name, level, health);
+System.out.println(formatted);
+// "Alice is level 10 with 85.5% health"
+```
+
+<Callout type="info" title="Format Specifiers">
+  Common format codes:
+
+  - `%s` - String
+  - `%d` - Integer
+  - `%f` - Floating point
+  - `%.2f` - Float with 2 decimal places
+  - `%n` - New line (platform independent)
+
+  ```java
+  String.format("Name: %s", "Steve");          // "Name: Steve"
+  String.format("Level: %d", 10);              // "Level: 10"
+  String.format("Health: %.1f", 85.5);         // "Health: 85.5"
+  String.format("Position: (%d, %d, %d)", 
+                10, 64, -5);                    // "Position: (10, 64, -5)"
+  ```
+</Callout>
+
+## Common String Operations
+
+### Check if String is Empty
+
+```java
+String text = "";
+
+// Check for empty or null
+if (text == null || text.isEmpty()) {
+    System.out.println("Empty!");
+}
+
+// Check for empty, null, or whitespace only
+if (text == null || text.trim().isEmpty()) {
+    System.out.println("Empty or whitespace!");
+}
+```
+
+### Count Occurrences
+
+```java
+public static int countOccurrences(String text, String target) {
+    int count = 0;
+    int index = 0;
+    
+    while ((index = text.indexOf(target, index)) != -1) {
+        count++;
+        index += target.length();
+    }
+    
+    return count;
+}
+
+// Usage
+int count = countOccurrences("hello hello world", "hello");
+System.out.println(count);  // 2
+```
+
+### Reverse a String
+
+```java
+public static String reverse(String text) {
+    StringBuilder sb = new StringBuilder(text);
+    return sb.reverse().toString();
+}
+
+// Usage
+String reversed = reverse("Hello");
+System.out.println(reversed);  // "olleH"
+```
+
+### Check if Palindrome
+
+```java
+public static boolean isPalindrome(String text) {
+    String cleaned = text.toLowerCase().replaceAll("[^a-z0-9]", "");
+    String reversed = new StringBuilder(cleaned).reverse().toString();
+    return cleaned.equals(reversed);
+}
+
+// Usage
+System.out.println(isPalindrome("racecar"));     // true
+System.out.println(isPalindrome("hello"));       // false
+```
+
+## Practice Exercises
+
+1. **Username Checker**: Write a method that checks if a username:
+   - Is between 3 and 16 characters
+   - Contains only letters, numbers, and underscores
+   - Doesn't start with a number
+   - Returns true if valid, false otherwise
+
+2. **Command Parser**: Parse this command format: `/teleport x y z`
+   - Extract the coordinates
+   - Convert them to integers
+   - Return an array of the three values
+
+3. **Chat Formatter**: Create a method that formats chat messages:
+   - Input: player name, rank, message
+   - Output: `"[RANK] PlayerName: message"`
+   - If no rank, just show `"PlayerName: message"`
+
+4. **Word Counter**: Count how many words are in a sentence (words are separated by spaces)
+
+5. **Title Case**: Convert a string to title case:
+   - Input: `"hello world"`
+   - Output: `"Hello World"`
diff --git a/content/docs/cs-CZ/guides/java-basics/10-arraylist.mdx b/content/docs/cs-CZ/guides/java-basics/10-arraylist.mdx
new file mode 100644
index 00000000..343ae5d5
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/10-arraylist.mdx
@@ -0,0 +1,530 @@
+---
+title: 10 - ArrayList and Collections
+description: Learn to use flexible, resizable collections in Java.
+---
+
+Arrays have a fixed size, but what if you need to add or remove elements? That's where `ArrayList` comes in - a resizable collection that grows and shrinks automatically.
+
+## ArrayList Basics
+
+```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]
+    }
+}
+```
+
+<Callout type="info" title="ArrayList vs Array">
+  | **Array**                               | **ArrayList**                                         |
+  | --------------------------------------- | ----------------------------------------------------- |
+  | Fixed size                              | Resizable (grows/shrinks)                             |
+  | Can hold primitives (int, double, etc.) | Can only hold objects (Integer, Double, String, etc.) |
+  | Faster access                           | More features (add, remove, etc.)                     |
+  | `int[] numbers = new int[10];`          | `ArrayList<Integer> numbers = new ArrayList<>();`     |
+</Callout>
+
+## Creating ArrayLists
+
+```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<>();
+```
+
+<Callout type="warning" title="Primitives in ArrayList">
+  You can't use primitives directly. Use their wrapper classes:
+
+  ```java
+  // Wrong
+  ArrayList<int> numbers = new ArrayList<>();
+
+  // Correct - Use wrapper class
+  ArrayList<Integer> numbers = new ArrayList<>();
+  ```
+
+  Wrapper classes:
+
+  - `int` → `Integer`
+  - `double` → `Double`
+  - `boolean` → `Boolean`
+  - `char` → `Character`
+</Callout>
+
+## Common ArrayList Methods
+
+### Adding Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+
+items.add("Sword");           // Add to end
+items.add("Shield");
+items.add(0, "Helmet");       // Add at specific index
+
+System.out.println(items);    // [Helmet, Sword, Shield]
+```
+
+### Accessing Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+String first = items.get(0);    // "Sword"
+String second = items.get(1);   // "Shield"
+
+int size = items.size();        // 2
+```
+
+### Removing Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+items.add("Potion");
+
+items.remove(1);               // Remove by index (Shield)
+items.remove("Potion");        // Remove by value
+
+System.out.println(items);     // [Sword]
+```
+
+### Checking Contents
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+boolean hasSword = items.contains("Sword");     // true
+boolean hasAxe = items.contains("Axe");         // false
+
+boolean isEmpty = items.isEmpty();              // false
+int size = items.size();                        // 2
+```
+
+### Modifying Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Wooden Sword");
+
+items.set(0, "Iron Sword");    // Replace at index 0
+
+System.out.println(items);     // [Iron Sword]
+```
+
+### Clearing All Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+items.clear();                 // Remove everything
+System.out.println(items);     // []
+```
+
+## Looping Through ArrayList
+
+### Using For Loop
+
+```java
+ArrayList<String> players = new ArrayList<>();
+players.add("Alice");
+players.add("Bob");
+players.add("Charlie");
+
+for (int i = 0; i < players.size(); i++) {
+    System.out.println(players.get(i));
+}
+```
+
+### Using Enhanced For Loop
+
+```java
+for (String player : players) {
+    System.out.println(player);
+}
+```
+
+### Using forEach (Java 8+)
+
+```java
+players.forEach(player -> System.out.println(player));
+```
+
+## Practical Examples
+
+### Player Inventory System
+
+```java
+import java.util.ArrayList;
+
+public class Inventory {
+    private ArrayList<String> items;
+    private int maxSize;
+    
+    public Inventory(int maxSize) {
+        this.items = new ArrayList<>();
+        this.maxSize = maxSize;
+    }
+    
+    public boolean addItem(String item) {
+        if (items.size() >= maxSize) {
+            System.out.println("Inventory full!");
+            return false;
+        }
+        
+        items.add(item);
+        System.out.println("Added: " + item);
+        return true;
+    }
+    
+    public boolean removeItem(String item) {
+        if (items.remove(item)) {
+            System.out.println("Removed: " + item);
+            return true;
+        }
+        
+        System.out.println("Item not found!");
+        return false;
+    }
+    
+    public void displayInventory() {
+        System.out.println("=== Inventory (" + items.size() + "/" + maxSize + ") ===");
+        for (int i = 0; i < items.size(); i++) {
+            System.out.println((i + 1) + ". " + items.get(i));
+        }
+    }
+    
+    public int getItemCount() {
+        return items.size();
+    }
+    
+    public boolean isFull() {
+        return items.size() >= maxSize;
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        Inventory inv = new Inventory(5);
+        
+        inv.addItem("Sword");
+        inv.addItem("Shield");
+        inv.addItem("Potion");
+        inv.displayInventory();
+        
+        inv.removeItem("Shield");
+        inv.displayInventory();
+    }
+}
+```
+
+### Quest System
+
+```java
+import java.util.ArrayList;
+
+public class QuestManager {
+    private ArrayList<String> activeQuests;
+    private ArrayList<String> completedQuests;
+    
+    public QuestManager() {
+        this.activeQuests = new ArrayList<>();
+        this.completedQuests = new ArrayList<>();
+    }
+    
+    public void startQuest(String questName) {
+        if (!activeQuests.contains(questName)) {
+            activeQuests.add(questName);
+            System.out.println("Quest started: " + questName);
+        } else {
+            System.out.println("Quest already active!");
+        }
+    }
+    
+    public void completeQuest(String questName) {
+        if (activeQuests.remove(questName)) {
+            completedQuests.add(questName);
+            System.out.println("Quest completed: " + questName);
+        } else {
+            System.out.println("Quest not found in active quests!");
+        }
+    }
+    
+    public void displayQuests() {
+        System.out.println("\n=== Active Quests ===");
+        if (activeQuests.isEmpty()) {
+            System.out.println("No active quests");
+        } else {
+            for (String quest : activeQuests) {
+                System.out.println("- " + quest);
+            }
+        }
+        
+        System.out.println("\n=== Completed Quests ===");
+        if (completedQuests.isEmpty()) {
+            System.out.println("No completed quests");
+        } else {
+            for (String quest : completedQuests) {
+                System.out.println("" + quest);
+            }
+        }
+    }
+    
+    public int getTotalCompleted() {
+        return completedQuests.size();
+    }
+}
+```
+
+### Leaderboard System
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class Leaderboard {
+    private ArrayList<Integer> scores;
+    private ArrayList<String> players;
+    
+    public Leaderboard() {
+        this.scores = new ArrayList<>();
+        this.players = new ArrayList<>();
+    }
+    
+    public void addScore(String player, int score) {
+        players.add(player);
+        scores.add(score);
+        System.out.println(player + " scored " + score + " points!");
+    }
+    
+    public void displayTop(int count) {
+        System.out.println("\n=== Top " + count + " Players ===");
+        
+        // Create copies to sort
+        ArrayList<Integer> sortedScores = new ArrayList<>(scores);
+        ArrayList<String> sortedPlayers = new ArrayList<>(players);
+        
+        // Bubble sort (simple for learning)
+        for (int i = 0; i < sortedScores.size() - 1; i++) {
+            for (int j = 0; j < sortedScores.size() - i - 1; j++) {
+                if (sortedScores.get(j) < sortedScores.get(j + 1)) {
+                    // Swap scores
+                    int tempScore = sortedScores.get(j);
+                    sortedScores.set(j, sortedScores.get(j + 1));
+                    sortedScores.set(j + 1, tempScore);
+                    
+                    // Swap players
+                    String tempPlayer = sortedPlayers.get(j);
+                    sortedPlayers.set(j, sortedPlayers.get(j + 1));
+                    sortedPlayers.set(j + 1, tempPlayer);
+                }
+            }
+        }
+        
+        // Display top scores
+        int limit = Math.min(count, sortedScores.size());
+        for (int i = 0; i < limit; i++) {
+            System.out.println((i + 1) + ". " + sortedPlayers.get(i) + 
+                             " - " + sortedScores.get(i) + " points");
+        }
+    }
+}
+```
+
+### Online Players Tracker
+
+```java
+import java.util.ArrayList;
+
+public class OnlinePlayersTracker {
+    private ArrayList<String> onlinePlayers;
+    
+    public OnlinePlayersTracker() {
+        this.onlinePlayers = new ArrayList<>();
+    }
+    
+    public void playerJoin(String playerName) {
+        if (!onlinePlayers.contains(playerName)) {
+            onlinePlayers.add(playerName);
+            broadcast(playerName + " joined the game");
+            updatePlayerCount();
+        }
+    }
+    
+    public void playerLeave(String playerName) {
+        if (onlinePlayers.remove(playerName)) {
+            broadcast(playerName + " left the game");
+            updatePlayerCount();
+        }
+    }
+    
+    public boolean isOnline(String playerName) {
+        return onlinePlayers.contains(playerName);
+    }
+    
+    public int getPlayerCount() {
+        return onlinePlayers.size();
+    }
+    
+    public void listPlayers() {
+        System.out.println("\n=== Online Players (" + getPlayerCount() + ") ===");
+        for (String player : onlinePlayers) {
+            System.out.println("• " + player);
+        }
+    }
+    
+    private void broadcast(String message) {
+        System.out.println("[Server] " + message);
+    }
+    
+    private void updatePlayerCount() {
+        System.out.println("Players online: " + getPlayerCount());
+    }
+}
+```
+
+## ArrayList of Custom Objects
+
+You can store your own classes in ArrayLists:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    
+    public Player(String name, int level) {
+        this.name = name;
+        this.level = level;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public int getLevel() {
+        return level;
+    }
+    
+    @Override
+    public String toString() {
+        return name + " (Lv. " + level + ")";
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        ArrayList<Player> players = new ArrayList<>();
+        
+        players.add(new Player("Alice", 10));
+        players.add(new Player("Bob", 15));
+        players.add(new Player("Charlie", 8));
+        
+        // Display all players
+        for (Player player : players) {
+            System.out.println(player);
+        }
+        
+        // Find player by name
+        for (Player player : players) {
+            if (player.getName().equals("Bob")) {
+                System.out.println("Found: " + player);
+            }
+        }
+    }
+}
+```
+
+## Useful ArrayList Operations
+
+### Convert to Array
+
+```java
+ArrayList<String> list = new ArrayList<>();
+list.add("A");
+list.add("B");
+
+String[] array = list.toArray(new String[0]);
+```
+
+### Convert Array to ArrayList
+
+```java
+String[] array = {"A", "B", "C"};
+ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
+```
+
+### Copy an ArrayList
+
+```java
+ArrayList<String> original = new ArrayList<>();
+original.add("A");
+original.add("B");
+
+// Shallow copy
+ArrayList<String> copy = new ArrayList<>(original);
+```
+
+### Find Index of Element
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+int index = items.indexOf("Shield");  // 1
+int notFound = items.indexOf("Axe");  // -1
+```
+
+## Practice Exercises
+
+1. **Shopping Cart**: Create a shopping cart system:
+   - Add items
+   - Remove items
+   - Calculate total items
+   - Clear cart
+
+2. **Friend List**: Create a friend management system:
+   - Add friend
+   - Remove friend
+   - Check if someone is a friend
+   - Display all friends
+
+3. **Todo List**: Build a todo list:
+   - Add task
+   - Mark task as complete (move to completed list)
+   - Display active tasks
+   - Display completed tasks
+
+4. **High Scores**: Create a high score system:
+   - Add scores
+   - Display top 5 scores in order
+   - Remove lowest score if more than 10 scores exist
+
+---
diff --git a/content/docs/cs-CZ/guides/java-basics/11-hashmaps.mdx b/content/docs/cs-CZ/guides/java-basics/11-hashmaps.mdx
new file mode 100644
index 00000000..a06511cf
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/11-hashmaps.mdx
@@ -0,0 +1,568 @@
+---
+title: 11 - HashMap and Key-Value Storage
+description: Learn to store and retrieve data using key-value pairs.
+---
+
+A `HashMap` stores data in key-value pairs, like a real-world dictionary. You look up a word (key) to find its definition (value). This is perfect for player data, item properties, and configuration settings.
+
+## HashMap Basics
+
+```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);
+    }
+}
+```
+
+<Callout type="info" title="HashMap vs ArrayList">
+  | **HashMap**                     | **ArrayList**                 |
+  | ------------------------------- | ----------------------------- |
+  | Unordered                       | Ordered by index (0, 1, 2...) |
+  | Access by key (can be any type) | Access by position            |
+  | Good for looking up values      | Good for lists of items       |
+  | Each key is unique              | Can have duplicates           |
+
+  ```java
+  // ArrayList - access by number
+  ArrayList<String> players = new ArrayList<>();
+  players.add("Alice");
+  String player = players.get(0);  // Get first player
+
+  // HashMap - access by name
+  HashMap<String, Integer> levels = new HashMap<>();
+  levels.put("Alice", 10);
+  int level = levels.get("Alice");  // Get Alice's level
+  ```
+</Callout>
+
+## Common HashMap Methods
+
+### Adding and Updating
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+
+scores.put("Alice", 100);     // Add new entry
+scores.put("Bob", 150);
+scores.put("Alice", 200);     // Update existing (Alice now 200)
+```
+
+### Getting Values
+
+```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)
+```
+
+### Checking for Keys/Values
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+boolean hasAlice = scores.containsKey("Alice");    // true
+boolean hasDave = scores.containsKey("Dave");      // false
+
+boolean has100 = scores.containsValue(100);        // true
+boolean has200 = scores.containsValue(200);        // false
+```
+
+### Removing Entries
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+scores.put("Bob", 150);
+
+scores.remove("Alice");           // Remove by key
+System.out.println(scores);       // {Bob=150}
+
+scores.clear();                   // Remove everything
+System.out.println(scores);       // {}
+```
+
+### Size and Empty Check
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+int size = scores.size();         // 1
+boolean empty = scores.isEmpty(); // false
+```
+
+## Looping Through HashMap
+
+### Loop Through Keys
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+scores.put("Bob", 150);
+scores.put("Charlie", 75);
+
+for (String name : scores.keySet()) {
+    System.out.println(name);
+}
+// Output: Alice, Bob, Charlie (order may vary)
+```
+
+### Loop Through Values
+
+```java
+for (Integer score : scores.values()) {
+    System.out.println(score);
+}
+// Output: 100, 150, 75 (order may vary)
+```
+
+### Loop Through Both Keys and Values
+
+```java
+for (String name : scores.keySet()) {
+    int score = scores.get(name);
+    System.out.println(name + ": " + score);
+}
+
+// Or using entrySet (more efficient)
+for (var entry : scores.entrySet()) {
+    String name = entry.getKey();
+    int score = entry.getValue();
+    System.out.println(name + ": " + score);
+}
+```
+
+<Callout type="info" title="HashMap Order">
+  HashMap does **not** maintain insertion order! If you need order, use `LinkedHashMap`:
+
+  ```java
+  import java.util.LinkedHashMap;
+
+  LinkedHashMap<String, Integer> orderedScores = new LinkedHashMap<>();
+  orderedScores.put("Alice", 100);
+  orderedScores.put("Bob", 150);
+  orderedScores.put("Charlie", 75);
+
+  // Will print in insertion order
+  for (String name : orderedScores.keySet()) {
+      System.out.println(name);
+  }
+  // Output: Alice, Bob, Charlie (guaranteed order)
+  ```
+</Callout>
+
+## Practical Examples
+
+### Player Statistics System
+
+```java
+import java.util.HashMap;
+
+public class PlayerStats {
+    private HashMap<String, Integer> stats;
+    
+    public PlayerStats() {
+        this.stats = new HashMap<>();
+        // Initialize default stats
+        stats.put("health", 100);
+        stats.put("mana", 50);
+        stats.put("strength", 10);
+        stats.put("defense", 5);
+        stats.put("speed", 8);
+    }
+    
+    public int getStat(String statName) {
+        return stats.getOrDefault(statName, 0);
+    }
+    
+    public void setStat(String statName, int value) {
+        stats.put(statName, value);
+    }
+    
+    public void modifyStat(String statName, int amount) {
+        int current = getStat(statName);
+        stats.put(statName, current + amount);
+    }
+    
+    public void displayStats() {
+        System.out.println("=== Player Stats ===");
+        for (var entry : stats.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        PlayerStats stats = new PlayerStats();
+        stats.displayStats();
+        
+        stats.modifyStat("strength", 5);
+        stats.modifyStat("health", -20);
+        
+        System.out.println("\nAfter modifications:");
+        stats.displayStats();
+    }
+}
+```
+
+### Item Properties Database
+
+```java
+import java.util.HashMap;
+
+public class ItemDatabase {
+    private HashMap<String, HashMap<String, Object>> items;
+    
+    public ItemDatabase() {
+        this.items = new HashMap<>();
+    }
+    
+    public void addItem(String itemName) {
+        HashMap<String, Object> properties = new HashMap<>();
+        properties.put("damage", 0);
+        properties.put("durability", 100);
+        properties.put("rarity", "Common");
+        properties.put("stackable", true);
+        
+        items.put(itemName, properties);
+    }
+    
+    public void setProperty(String itemName, String property, Object value) {
+        if (items.containsKey(itemName)) {
+            items.get(itemName).put(property, value);
+        }
+    }
+    
+    public Object getProperty(String itemName, String property) {
+        if (items.containsKey(itemName)) {
+            return items.get(itemName).get(property);
+        }
+        return null;
+    }
+    
+    public void displayItem(String itemName) {
+        if (!items.containsKey(itemName)) {
+            System.out.println("Item not found!");
+            return;
+        }
+        
+        System.out.println("=== " + itemName + " ===");
+        HashMap<String, Object> props = items.get(itemName);
+        for (var entry : props.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        ItemDatabase db = new ItemDatabase();
+        
+        db.addItem("Iron Sword");
+        db.setProperty("Iron Sword", "damage", 15);
+        db.setProperty("Iron Sword", "rarity", "Uncommon");
+        
+        db.displayItem("Iron Sword");
+    }
+}
+```
+
+### Configuration Manager
+
+```java
+import java.util.HashMap;
+
+public class GameConfig {
+    private HashMap<String, String> settings;
+    
+    public GameConfig() {
+        this.settings = new HashMap<>();
+        loadDefaults();
+    }
+    
+    private void loadDefaults() {
+        settings.put("difficulty", "normal");
+        settings.put("musicVolume", "50");
+        settings.put("sfxVolume", "50");
+        settings.put("renderDistance", "10");
+        settings.put("showFPS", "false");
+    }
+    
+    public String getSetting(String key) {
+        return settings.getOrDefault(key, "");
+    }
+    
+    public void setSetting(String key, String value) {
+        settings.put(key, value);
+        System.out.println("Set " + key + " to " + value);
+    }
+    
+    public int getIntSetting(String key) {
+        String value = getSetting(key);
+        try {
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            return 0;
+        }
+    }
+    
+    public boolean getBooleanSetting(String key) {
+        return "true".equalsIgnoreCase(getSetting(key));
+    }
+    
+    public void displaySettings() {
+        System.out.println("=== Game Settings ===");
+        for (var entry : settings.entrySet()) {
+            System.out.println(entry.getKey() + " = " + entry.getValue());
+        }
+    }
+}
+```
+
+### Player Inventory with Quantities
+
+```java
+import java.util.HashMap;
+
+public class Inventory {
+    private HashMap<String, Integer> items;
+    private int maxSlots;
+    
+    public Inventory(int maxSlots) {
+        this.items = new HashMap<>();
+        this.maxSlots = maxSlots;
+    }
+    
+    public boolean addItem(String itemName, int quantity) {
+        if (items.size() >= maxSlots && !items.containsKey(itemName)) {
+            System.out.println("Inventory full!");
+            return false;
+        }
+        
+        int current = items.getOrDefault(itemName, 0);
+        items.put(itemName, current + quantity);
+        System.out.println("Added " + quantity + "x " + itemName);
+        return true;
+    }
+    
+    public boolean removeItem(String itemName, int quantity) {
+        if (!items.containsKey(itemName)) {
+            System.out.println("Don't have that item!");
+            return false;
+        }
+        
+        int current = items.get(itemName);
+        if (current < quantity) {
+            System.out.println("Not enough " + itemName);
+            return false;
+        }
+        
+        if (current == quantity) {
+            items.remove(itemName);
+        } else {
+            items.put(itemName, current - quantity);
+        }
+        
+        System.out.println("Removed " + quantity + "x " + itemName);
+        return true;
+    }
+    
+    public int getQuantity(String itemName) {
+        return items.getOrDefault(itemName, 0);
+    }
+    
+    public boolean hasItem(String itemName) {
+        return items.containsKey(itemName);
+    }
+    
+    public void displayInventory() {
+        System.out.println("\n=== Inventory (" + items.size() + "/" + maxSlots + " slots) ===");
+        if (items.isEmpty()) {
+            System.out.println("Empty");
+        } else {
+            for (var entry : items.entrySet()) {
+                System.out.println(entry.getKey() + " x" + entry.getValue());
+            }
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        Inventory inv = new Inventory(10);
+        
+        inv.addItem("Wood", 64);
+        inv.addItem("Stone", 32);
+        inv.addItem("Wood", 20);  // Adds to existing
+        
+        inv.displayInventory();
+        
+        inv.removeItem("Wood", 50);
+        inv.displayInventory();
+    }
+}
+```
+
+### Cooldown Manager
+
+```java
+import java.util.HashMap;
+
+public class CooldownManager {
+    private HashMap<String, Long> cooldowns;
+    
+    public CooldownManager() {
+        this.cooldowns = new HashMap<>();
+    }
+    
+    public void startCooldown(String ability, long durationMs) {
+        long endTime = System.currentTimeMillis() + durationMs;
+        cooldowns.put(ability, endTime);
+        System.out.println(ability + " on cooldown for " + (durationMs / 1000) + " seconds");
+    }
+    
+    public boolean isOnCooldown(String ability) {
+        if (!cooldowns.containsKey(ability)) {
+            return false;
+        }
+        
+        long endTime = cooldowns.get(ability);
+        long now = System.currentTimeMillis();
+        
+        if (now >= endTime) {
+            cooldowns.remove(ability);
+            return false;
+        }
+        
+        return true;
+    }
+    
+    public long getRemainingTime(String ability) {
+        if (!isOnCooldown(ability)) {
+            return 0;
+        }
+        
+        long endTime = cooldowns.get(ability);
+        long now = System.currentTimeMillis();
+        return (endTime - now) / 1000;  // Return seconds
+    }
+    
+    public boolean useAbility(String ability, long cooldownSeconds) {
+        if (isOnCooldown(ability)) {
+            long remaining = getRemainingTime(ability);
+            System.out.println(ability + " is on cooldown (" + remaining + "s remaining)");
+            return false;
+        }
+        
+        System.out.println("Used " + ability + "!");
+        startCooldown(ability, cooldownSeconds * 1000);
+        return true;
+    }
+}
+```
+
+## HashMap with Custom Objects
+
+Store your own classes as values:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    private int health;
+    
+    public Player(String name, int level) {
+        this.name = name;
+        this.level = level;
+        this.health = 100;
+    }
+    
+    // Getters and setters...
+    
+    @Override
+    public String toString() {
+        return name + " (Lv. " + level + ", HP: " + health + ")";
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        HashMap<String, Player> players = new HashMap<>();
+        
+        players.put("player1", new Player("Alice", 10));
+        players.put("player2", new Player("Bob", 15));
+        
+        // Get and use player
+        Player alice = players.get("player1");
+        System.out.println(alice);
+    }
+}
+```
+
+## Nested HashMaps
+
+HashMaps can contain other HashMaps:
+
+```java
+// Store multiple properties per player
+HashMap<String, HashMap<String, Integer>> playerData = new HashMap<>();
+
+// Add player with stats
+HashMap<String, Integer> aliceStats = new HashMap<>();
+aliceStats.put("level", 10);
+aliceStats.put("health", 100);
+aliceStats.put("mana", 50);
+playerData.put("Alice", aliceStats);
+
+// Access nested data
+int aliceLevel = playerData.get("Alice").get("level");
+System.out.println("Alice's level: " + aliceLevel);
+```
+
+## Practice Exercises
+
+1. **Phone Book**: Create a phone book that stores names and phone numbers. Add methods to:
+   - Add contact
+   - Find number by name
+   - Delete contact
+   - Display all contacts
+
+2. **Grade Manager**: Store student names and grades. Create methods to:
+   - Add student with grade
+   - Update grade
+   - Calculate class average
+   - Find highest grade
+
+3. **Word Counter**: Write a program that counts how many times each word appears in a sentence using a HashMap.
+
+4. **Item Shop**: Create a shop where items have names and prices. Add methods to:
+   - Add item with price
+   - Get item price
+   - Apply discount to all items
+   - Display all items and prices
+
+---
diff --git a/content/docs/cs-CZ/guides/java-basics/12-exception-handling.mdx b/content/docs/cs-CZ/guides/java-basics/12-exception-handling.mdx
new file mode 100644
index 00000000..a43155d0
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/12-exception-handling.mdx
@@ -0,0 +1,504 @@
+---
+title: 12 - Exception Handling
+description: Learn how to handle errors gracefully in your Java programs.
+---
+
+Exceptions are errors that occur while your program is running. Instead of crashing, you can "catch" these errors and handle them gracefully.
+
+## What is an Exception?
+
+An exception is an event that disrupts the normal flow of your program:
+
+```java
+String text = null;
+System.out.println(text.length());  // NullPointerException - crashes!
+```
+
+Without handling, this crashes your mod and breaks the game!
+
+## Try-Catch Blocks
+
+Use `try-catch` to handle exceptions:
+
+```java
+try {
+    // Code that might throw an exception
+    String text = null;
+    System.out.println(text.length());
+} catch (NullPointerException e) {
+    // Code to handle the error
+    System.out.println("Error: text was null!");
+}
+
+System.out.println("Program continues...");
+```
+
+<Callout type="info" title="How Try-Catch Works">
+  1. Code in `try` block runs normally
+  2. If an exception occurs, execution jumps to `catch` block
+  3. After `catch` block, program continues normally
+  4. If no exception occurs, `catch` block is skipped
+
+  ```java
+  try {
+      // Try to do something risky
+      int result = 10 / 0;  // Division by zero!
+  } catch (ArithmeticException e) {
+      // Handle the error
+      System.out.println("Can't divide by zero!");
+  }
+  // Program keeps running
+  ```
+</Callout>
+
+## Common Exception Types
+
+### NullPointerException
+
+Accessing methods/properties on null objects:
+
+```java
+String name = null;
+
+try {
+    int length = name.length();
+} catch (NullPointerException e) {
+    System.out.println("Name is null!");
+}
+```
+
+### ArrayIndexOutOfBoundsException
+
+Accessing invalid array index:
+
+```java
+int[] numbers = {1, 2, 3};
+
+try {
+    int value = numbers[10];  // Index 10 doesn't exist!
+} catch (ArrayIndexOutOfBoundsException e) {
+    System.out.println("Invalid array index!");
+}
+```
+
+### NumberFormatException
+
+Converting invalid strings to numbers:
+
+```java
+try {
+    int number = Integer.parseInt("abc");  // Not a number!
+} catch (NumberFormatException e) {
+    System.out.println("Invalid number format!");
+}
+```
+
+### ArithmeticException
+
+Math errors like division by zero:
+
+```java
+try {
+    int result = 10 / 0;
+} catch (ArithmeticException e) {
+    System.out.println("Math error!");
+}
+```
+
+## Multiple Catch Blocks
+
+Handle different exceptions differently:
+
+```java
+String input = "abc";
+
+try {
+    int number = Integer.parseInt(input);
+    int result = 100 / number;
+    System.out.println(result);
+} catch (NumberFormatException e) {
+    System.out.println("Invalid number!");
+} catch (ArithmeticException e) {
+    System.out.println("Cannot divide by zero!");
+}
+```
+
+## Catching Multiple Exception Types
+
+Catch multiple exceptions in one block:
+
+```java
+try {
+    // Some risky code
+} catch (NumberFormatException | ArithmeticException e) {
+    System.out.println("Math-related error occurred!");
+}
+```
+
+## The Finally Block
+
+Code that **always** runs, whether exception occurs or not:
+
+```java
+try {
+    System.out.println("Opening file...");
+    // Code that might fail
+} catch (Exception e) {
+    System.out.println("Error: " + e.getMessage());
+} finally {
+    System.out.println("Closing file...");
+    // This ALWAYS runs - good for cleanup
+}
+```
+
+<Callout type="info" title="When to Use Finally">
+  Use `finally` for cleanup tasks that must always happen:
+
+  - Closing files
+  - Releasing resources
+  - Saving data
+  - Logging
+
+  ```java
+  FileReader file = null;
+  try {
+      file = new FileReader("data.txt");
+      // Read file
+  } catch (Exception e) {
+      System.out.println("Error reading file");
+  } finally {
+      if (file != null) {
+          file.close();  // Always close the file!
+      }
+  }
+  ```
+</Callout>
+
+## Getting Exception Information
+
+The exception object contains useful information:
+
+```java
+try {
+    int result = Integer.parseInt("xyz");
+} catch (NumberFormatException e) {
+    System.out.println("Message: " + e.getMessage());
+    System.out.println("Type: " + e.getClass().getName());
+    e.printStackTrace();  // Print full error details
+}
+```
+
+## Practical Examples
+
+### Safe Player Input
+
+```java
+import java.util.Scanner;
+
+public class PlayerInput {
+    public static int getPlayerChoice(Scanner scanner) {
+        while (true) {
+            try {
+                System.out.print("Enter choice (1-5): ");
+                String input = scanner.nextLine();
+                int choice = Integer.parseInt(input);
+                
+                if (choice < 1 || choice > 5) {
+                    System.out.println("Please enter a number between 1 and 5");
+                    continue;
+                }
+                
+                return choice;
+            } catch (NumberFormatException e) {
+                System.out.println("Invalid input! Please enter a number.");
+            }
+        }
+    }
+    
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int choice = getPlayerChoice(scanner);
+        System.out.println("You chose: " + choice);
+    }
+}
+```
+
+### Safe Item Durability Update
+
+```java
+public class Item {
+    private String name;
+    private int durability;
+    private int maxDurability;
+    
+    public Item(String name, int maxDurability) {
+        this.name = name;
+        this.durability = maxDurability;
+        this.maxDurability = maxDurability;
+    }
+    
+    public void damage(int amount) {
+        try {
+            if (amount < 0) {
+                throw new IllegalArgumentException("Damage cannot be negative!");
+            }
+            
+            durability -= amount;
+            
+            if (durability < 0) {
+                durability = 0;
+            }
+            
+            System.out.println(name + " durability: " + durability + "/" + maxDurability);
+            
+            if (durability == 0) {
+                System.out.println(name + " broke!");
+            }
+        } catch (IllegalArgumentException e) {
+            System.out.println("Error: " + e.getMessage());
+        }
+    }
+}
+```
+
+### Safe Config Loading
+
+```java
+import java.util.HashMap;
+
+public class ConfigLoader {
+    private HashMap<String, String> settings;
+    
+    public ConfigLoader() {
+        this.settings = new HashMap<>();
+        loadDefaults();
+    }
+    
+    private void loadDefaults() {
+        settings.put("maxPlayers", "10");
+        settings.put("difficulty", "normal");
+        settings.put("pvpEnabled", "true");
+    }
+    
+    public int getIntSetting(String key, int defaultValue) {
+        try {
+            String value = settings.get(key);
+            if (value == null) {
+                return defaultValue;
+            }
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            System.out.println("Invalid number for " + key + ", using default");
+            return defaultValue;
+        }
+    }
+    
+    public boolean getBooleanSetting(String key, boolean defaultValue) {
+        try {
+            String value = settings.get(key);
+            if (value == null) {
+                return defaultValue;
+            }
+            return Boolean.parseBoolean(value);
+        } catch (Exception e) {
+            System.out.println("Invalid boolean for " + key + ", using default");
+            return defaultValue;
+        }
+    }
+    
+    public void setSetting(String key, String value) {
+        if (key == null || value == null) {
+            System.out.println("Key and value cannot be null!");
+            return;
+        }
+        settings.put(key, value);
+    }
+}
+```
+
+### Safe Array Access
+
+```java
+public class Inventory {
+    private String[] items;
+    
+    public Inventory(int size) {
+        this.items = new String[size];
+    }
+    
+    public boolean setItem(int slot, String item) {
+        try {
+            if (slot < 0 || slot >= items.length) {
+                throw new ArrayIndexOutOfBoundsException("Invalid slot: " + slot);
+            }
+            
+            items[slot] = item;
+            System.out.println("Placed " + item + " in slot " + slot);
+            return true;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Error: " + e.getMessage());
+            return false;
+        }
+    }
+    
+    public String getItem(int slot) {
+        try {
+            return items[slot];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Invalid slot: " + slot);
+            return null;
+        }
+    }
+}
+```
+
+### Command Parser with Error Handling
+
+```java
+public class CommandParser {
+    public static void parseCommand(String command) {
+        try {
+            if (command == null || command.trim().isEmpty()) {
+                throw new IllegalArgumentException("Command cannot be empty!");
+            }
+            
+            String[] parts = command.split(" ");
+            
+            if (parts.length < 2) {
+                throw new IllegalArgumentException("Invalid command format!");
+            }
+            
+            String action = parts[0];
+            String target = parts[1];
+            
+            switch (action) {
+                case "give":
+                    if (parts.length < 4) {
+                        throw new IllegalArgumentException("Usage: give <player> <item> <amount>");
+                    }
+                    String item = parts[2];
+                    int amount = Integer.parseInt(parts[3]);
+                    
+                    if (amount <= 0) {
+                        throw new IllegalArgumentException("Amount must be positive!");
+                    }
+                    
+                    System.out.println("Giving " + amount + " " + item + " to " + target);
+                    break;
+                    
+                case "tp":
+                    if (parts.length < 5) {
+                        throw new IllegalArgumentException("Usage: tp <player> <x> <y> <z>");
+                    }
+                    int x = Integer.parseInt(parts[2]);
+                    int y = Integer.parseInt(parts[3]);
+                    int z = Integer.parseInt(parts[4]);
+                    
+                    System.out.println("Teleporting " + target + " to " + x + ", " + y + ", " + z);
+                    break;
+                    
+                default:
+                    throw new IllegalArgumentException("Unknown command: " + action);
+            }
+        } catch (NumberFormatException e) {
+            System.out.println("Error: Invalid number in command!");
+        } catch (IllegalArgumentException e) {
+            System.out.println("Error: " + e.getMessage());
+        } catch (Exception e) {
+            System.out.println("Unexpected error: " + e.getMessage());
+        }
+    }
+    
+    public static void main(String[] args) {
+        parseCommand("give Steve diamond 5");
+        parseCommand("give Steve sword abc");  // Invalid number
+        parseCommand("tp Alice 10 64 20");
+        parseCommand("unknown command");       // Unknown command
+    }
+}
+```
+
+## Throwing Exceptions
+
+You can throw your own exceptions:
+
+```java
+public class Player {
+    private int health;
+    
+    public void setHealth(int health) {
+        if (health < 0) {
+            throw new IllegalArgumentException("Health cannot be negative!");
+        }
+        if (health > 100) {
+            throw new IllegalArgumentException("Health cannot exceed 100!");
+        }
+        this.health = health;
+    }
+}
+```
+
+<Callout type="info" title="When to Throw Exceptions">
+  Throw exceptions when:
+
+  - Method receives invalid input
+  - Operation cannot be completed
+  - Preconditions are not met
+  - Something unexpected happens
+
+  ```java
+  public void damagePlayer(int damage) {
+      if (damage < 0) {
+          throw new IllegalArgumentException("Damage must be positive!");
+      }
+      // Apply damage
+  }
+
+  public Item getItem(int slot) {
+      if (slot < 0 || slot >= inventory.length) {
+          throw new IndexOutOfBoundsException("Invalid inventory slot!");
+      }
+      return inventory[slot];
+  }
+  ```
+</Callout>
+
+## Checked vs Unchecked Exceptions
+
+<Callout type="warning" title="Exception Types">
+  **Unchecked Exceptions** (RuntimeException):
+
+  - Don't need to be caught
+  - Usually programming errors
+  - Examples: NullPointerException, ArrayIndexOutOfBoundsException
+
+  **Checked Exceptions**:
+
+  - Must be caught or declared
+  - Usually external errors (files, network)
+  - Examples: IOException, FileNotFoundException
+
+  ```java
+  // Unchecked - no need to catch
+  int result = 10 / 0;  // ArithmeticException
+
+  // Checked - must catch or declare
+  try {
+      FileReader file = new FileReader("data.txt");  // IOException
+  } catch (IOException e) {
+      // Handle error
+  }
+  ```
+</Callout>
+
+## Practice Exercises
+
+1. **Safe Division Calculator**: Create a method that divides two numbers. Handle division by zero and invalid input gracefully.
+
+2. **Player Level Setter**: Create a method that sets player level (1-100). Throw an exception if invalid, and handle it in main.
+
+3. **Safe Array Access**: Create a method that safely accesses array elements. Return null if index is invalid instead of crashing.
+
+4. **Config Parser**: Read a config string like "maxPlayers=10" and parse it. Handle invalid formats gracefully.
+
+5. **File Name Validator**: Create a method that checks if a filename is valid (no special characters, not empty). Throw exceptions for invalid names.
diff --git a/content/docs/cs-CZ/guides/java-basics/13-inheritance.mdx b/content/docs/cs-CZ/guides/java-basics/13-inheritance.mdx
new file mode 100644
index 00000000..1650c27a
--- /dev/null
+++ b/content/docs/cs-CZ/guides/java-basics/13-inheritance.mdx
@@ -0,0 +1,629 @@
+---
+title: 13 - Inheritance
+description: Learn how to create class hierarchies and reuse code effectively.
+---
+
+Inheritance lets you create new classes based on existing ones. The new class inherits all the properties and methods of the parent class, and can add its own or modify inherited ones.
+
+## What is Inheritance?
+
+Think of inheritance like a family tree. A child inherits traits from their parent, but can also have their own unique traits.
+
+```java
+// Parent class (superclass)
+public class Entity {
+    protected String name;
+    protected int health;
+    
+    public Entity(String name, int health) {
+        this.name = name;
+        this.health = health;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+    }
+}
+
+// Child class (subclass)
+public class Player extends Entity {
+    private int level;
+    
+    public Player(String name, int health, int level) {
+        super(name, health);  // Call parent constructor
+        this.level = level;
+    }
+    
+    public void levelUp() {
+        level++;
+        System.out.println(name + " leveled up to " + level + "!");
+    }
+}
+```
+
+<Callout type="info" title="Inheritance Terminology">
+  - **Superclass/Parent**: The class being inherited from (Entity)
+  - **Subclass/Child**: The class inheriting (Player)
+  - **extends**: Keyword to inherit from a class
+  - **super**: Keyword to access parent class members
+
+  ```java
+  public class Monster extends Entity {
+      // Monster IS-A Entity
+      // Monster inherits from Entity
+      // Entity is the parent, Monster is the child
+  }
+  ```
+</Callout>
+
+## The extends Keyword
+
+Use `extends` to inherit from a class:
+
+```java
+public class Animal {
+    protected String name;
+    
+    public void makeSound() {
+        System.out.println(name + " makes a sound");
+    }
+}
+
+public class Dog extends Animal {
+    public void wagTail() {
+        System.out.println(name + " wags tail");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Dog dog = new Dog();
+        dog.name = "Buddy";
+        dog.makeSound();  // Inherited from Animal
+        dog.wagTail();    // Dog's own method
+    }
+}
+```
+
+## The super Keyword
+
+`super` refers to the parent class:
+
+### Calling Parent Constructor
+
+```java
+public class Entity {
+    protected String name;
+    
+    public Entity(String name) {
+        this.name = name;
+    }
+}
+
+public class Player extends Entity {
+    private int level;
+    
+    public Player(String name, int level) {
+        super(name);  // Call parent constructor FIRST
+        this.level = level;
+    }
+}
+```
+
+<Callout type="warning" title="Constructor Rules">
+  - `super()` must be the **first** statement in child constructor
+  - If you don't call `super()`, Java automatically calls the no-argument parent constructor
+  - If parent has no no-argument constructor, you MUST call `super()` with arguments
+
+  ```java
+  // Wrong - super() not first
+  public Player(String name, int level) {
+      this.level = level;
+      super(name);  // Error!
+  }
+
+  // Correct
+  public Player(String name, int level) {
+      super(name);  // First statement
+      this.level = level;
+  }
+  ```
+</Callout>
+
+### Calling Parent Methods
+
+```java
+public class Entity {
+    protected int health;
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println("Entity took damage!");
+    }
+}
+
+public class Player extends Entity {
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);  // Call parent version
+        if (health < 20) {
+            System.out.println("Warning: Low health!");
+        }
+    }
+}
+```
+
+## Method Overriding
+
+Child classes can replace parent methods:
+
+```java
+public class Entity {
+    public void attack() {
+        System.out.println("Entity attacks!");
+    }
+}
+
+public class Player extends Entity {
+    @Override  // Good practice to use this annotation
+    public void attack() {
+        System.out.println("Player swings sword!");
+    }
+}
+
+public class Monster extends Entity {
+    @Override
+    public void attack() {
+        System.out.println("Monster bites!");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Player player = new Player();
+        Monster monster = new Monster();
+        
+        player.attack();   // "Player swings sword!"
+        monster.attack();  // "Monster bites!"
+    }
+}
+```
+
+<Callout type="info" title="@Override Annotation">
+  Always use `@Override` when overriding methods:
+
+  - Helps catch typos (if method doesn't exist in parent, you get an error)
+  - Makes code clearer
+  - Good documentation
+
+  ```java
+  // Without @Override - typo not caught
+  public void attac() {  // Typo! Creates new method instead
+      // ...
+  }
+
+  // With @Override - error caught immediately
+  @Override
+  public void attac() {  // Error: method doesn't exist in parent
+      // ...
+  }
+  ```
+</Callout>
+
+## Access Modifiers in Inheritance
+
+- `public` - Accessible everywhere
+- `protected` - Accessible in class and subclasses
+- `private` - Only in the class (not inherited)
+
+```java
+public class Parent {
+    public int publicVar;      // Child can access
+    protected int protectedVar; // Child can access
+    private int privateVar;     // Child CANNOT access
+    
+    private void privateMethod() {
+        // Child cannot call this
+    }
+    
+    protected void protectedMethod() {
+        // Child can call this
+    }
+}
+
+public class Child extends Parent {
+    public void test() {
+        publicVar = 10;      // OK
+        protectedVar = 20;   // OK
+        privateVar = 30;     // Error!
+        
+        protectedMethod();   // OK
+        privateMethod();     // Error!
+    }
+}
+```
+
+## Practical Examples
+
+### Game Entity Hierarchy
+
+```java
+// Base class for all entities
+public class Entity {
+    protected String name;
+    protected int health;
+    protected int maxHealth;
+    protected double x, y, z;
+    
+    public Entity(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        if (health < 0) health = 0;
+        System.out.println(name + " took " + damage + " damage. Health: " + health);
+    }
+    
+    public boolean isAlive() {
+        return health > 0;
+    }
+    
+    public void moveTo(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        System.out.println(name + " moved to (" + x + ", " + y + ", " + z + ")");
+    }
+}
+
+// Player extends Entity
+public class Player extends Entity {
+    private int level;
+    private int experience;
+    private int mana;
+    
+    public Player(String name) {
+        super(name, 100);
+        this.level = 1;
+        this.experience = 0;
+        this.mana = 50;
+    }
+    
+    public void gainExperience(int amount) {
+        experience += amount;
+        System.out.println("Gained " + amount + " XP");
+        
+        if (experience >= level * 100) {
+            levelUp();
+        }
+    }
+    
+    private void levelUp() {
+        level++;
+        maxHealth += 10;
+        health = maxHealth;
+        mana += 5;
+        System.out.println("Level up! Now level " + level);
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        if (health < maxHealth * 0.25) {
+            System.out.println("⚠ WARNING: Low health!");
+        }
+    }
+}
+
+// Monster extends Entity
+public class Monster extends Entity {
+    private int attackPower;
+    private String type;
+    
+    public Monster(String name, int health, int attackPower, String type) {
+        super(name, health);
+        this.attackPower = attackPower;
+        this.type = type;
+    }
+    
+    public int attack() {
+        System.out.println(name + " attacks!");
+        return attackPower;
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        if (!isAlive()) {
+            System.out.println(name + " was defeated!");
+        }
+    }
+}
+
+// Boss extends Monster (multi-level inheritance)
+public class Boss extends Monster {
+    private int phase;
+    
+    public Boss(String name, int health, int attackPower) {
+        super(name, health, attackPower, "Boss");
+        this.phase = 1;
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        
+        // Change phase at 50% health
+        if (phase == 1 && health < maxHealth / 2) {
+            phase = 2;
+            System.out.println(name + " enters PHASE 2!");
+        }
+    }
+    
+    @Override
+    public int attack() {
+        int damage = super.attack();
+        if (phase == 2) {
+            damage *= 2;
+            System.out.println("ENRAGED ATTACK!");
+        }
+        return damage;
+    }
+}
+```
+
+### Item Hierarchy
+
+```java
+// Base Item class
+public class Item {
+    protected String name;
+    protected int value;
+    protected double weight;
+    
+    public Item(String name, int value, double weight) {
+        this.name = name;
+        this.value = value;
+        this.weight = weight;
+    }
+    
+    public void use() {
+        System.out.println("Using " + name);
+    }
+    
+    public String getInfo() {
+        return name + " ($" + value + ", " + weight + " kg)";
+    }
+}
+
+// Weapon extends Item
+public class Weapon extends Item {
+    private int damage;
+    private int durability;
+    
+    public Weapon(String name, int value, double weight, int damage, int durability) {
+        super(name, value, weight);
+        this.damage = damage;
+        this.durability = durability;
+    }
+    
+    @Override
+    public void use() {
+        if (durability > 0) {
+            System.out.println("Attacking with " + name + " for " + damage + " damage!");
+            durability--;
+        } else {
+            System.out.println(name + " is broken!");
+        }
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Damage: " + damage + ", Durability: " + durability;
+    }
+}
+
+// Consumable extends Item
+public class Consumable extends Item {
+    private int healAmount;
+    private int uses;
+    
+    public Consumable(String name, int value, double weight, int healAmount, int uses) {
+        super(name, value, weight);
+        this.healAmount = healAmount;
+        this.uses = uses;
+    }
+    
+    @Override
+    public void use() {
+        if (uses > 0) {
+            System.out.println("Used " + name + ", restored " + healAmount + " health!");
+            uses--;
+        } else {
+            System.out.println("No " + name + " left!");
+        }
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Heals: " + healAmount + ", Uses: " + uses;
+    }
+}
+
+// Armor extends Item
+public class Armor extends Item {
+    private int defense;
+    private String slot;
+    
+    public Armor(String name, int value, double weight, int defense, String slot) {
+        super(name, value, weight);
+        this.defense = defense;
+        this.slot = slot;
+    }
+    
+    @Override
+    public void use() {
+        System.out.println("Equipped " + name + " (+" + defense + " defense)");
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Defense: " + defense + ", Slot: " + slot;
+    }
+}
+```
+
+## Polymorphism
+
+Child objects can be treated as parent objects:
+
+```java
+Entity entity1 = new Player("Alice");
+Entity entity2 = new Monster("Goblin", 50, 10, "Hostile");
+Entity entity3 = new Boss("Dragon", 500, 50);
+
+// All can use Entity methods
+entity1.takeDamage(10);
+entity2.takeDamage(10);
+entity3.takeDamage(10);
+
+// Array of different types
+Entity[] entities = {
+    new Player("Bob"),
+    new Monster("Zombie", 30, 8, "Hostile"),
+    new Monster("Spider", 20, 5, "Hostile")
+};
+
+// Process all entities the same way
+for (Entity entity : entities) {
+    entity.takeDamage(5);
+}
+```
+
+<Callout type="info" title="Polymorphism Benefits">
+  Polymorphism lets you write code that works with parent types but handles child types correctly:
+
+  ```java
+  public void damageEntity(Entity entity, int damage) {
+      entity.takeDamage(damage);
+      // Works for Player, Monster, Boss, etc.
+      // Each uses their own version of takeDamage()
+  }
+
+  // Can call with any Entity type
+  damageEntity(new Player("Alice"), 10);
+  damageEntity(new Monster("Goblin", 50, 10, "Hostile"), 10);
+  damageEntity(new Boss("Dragon", 500, 50), 10);
+  ```
+</Callout>
+
+## The Object Class
+
+All classes in Java automatically inherit from `Object`:
+
+```java
+public class MyClass {
+    // Automatically extends Object
+    // Has methods like toString(), equals(), etc.
+}
+```
+
+Common Object methods to override:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    
+    @Override
+    public String toString() {
+        return "Player: " + name + " (Lv. " + level + ")";
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Player) {
+            Player other = (Player) obj;
+            return this.name.equals(other.name);
+        }
+        return false;
+    }
+}
+```
+
+## Final Classes and Methods
+
+`final` prevents inheritance or overriding:
+
+```java
+// Final class - cannot be extended
+public final class SpecialItem {
+    // No class can extend this
+}
+
+// Final method - cannot be overridden
+public class Entity {
+    public final void printName() {
+        System.out.println(name);
+    }
+}
+
+public class Player extends Entity {
+    @Override
+    public void printName() {  // Error! Method is final
+        // Cannot override
+    }
+}
+```
+
+## Common Mistakes
+
+```java
+// Wrong - Forgetting super()
+public class Player extends Entity {
+    public Player(String name) {
+        // Error! Entity has no no-arg constructor
+    }
+}
+
+// Correct
+public class Player extends Entity {
+    public Player(String name) {
+        super(name, 100);  // Call parent constructor
+    }
+}
+
+// Wrong - Accessing private members
+public class Child extends Parent {
+    public void test() {
+        privateVar = 10;  // Error! private is not inherited
+    }
+}
+
+// Correct - Use protected
+public class Parent {
+    protected int protectedVar;  // Child can access
+}
+
+// Wrong - Multiple inheritance (not allowed in Java)
+public class Child extends Parent1, Parent2 {  // Error!
+}
+
+// Correct - Single inheritance only
+public class Child extends Parent {
+}
+```
+
+## Practice Exercises
+
+1. **Vehicle Hierarchy**: Create a `Vehicle` class with properties like speed and fuel. Create `Car` and `Motorcycle` subclasses with their own unique features.
+
+2. **Shape Calculator**: Create a `Shape` class with a `calculateArea()` method. Create `Circle`, `Rectangle`, and `Triangle` subclasses that override this method.
+
+3. **RPG Characters**: Create a `Character` class. Extend it to make `Warrior`, `Mage`, and `Archer` classes with unique abilities.
+
+4. **Animal Sounds**: Create an `Animal` class with a `makeSound()` method. Create various animal subclasses that override this method.
diff --git a/content/docs/cs-CZ/guides/learning-to-learn.mdx b/content/docs/cs-CZ/guides/learning-to-learn.mdx
new file mode 100644
index 00000000..567e514e
--- /dev/null
+++ b/content/docs/cs-CZ/guides/learning-to-learn.mdx
@@ -0,0 +1,37 @@
+---
+title: Learning to Learn
+description: A guide to help you become a better learner and adapt to new information effectively.
+icon: CircleQuestionMark
+---
+
+## Why learn to code? We have visual scripting!
+
+Yes we do, and honestly you should try that out. Visual scripting is a great addition to Hytale and we know it'll be powerful, but nothing beats the ability of being able to read and write Java code, with the ability to build even more powerful mods and plugins.
+
+<Callout type="info" title="Visual Scripting vs Coding">
+  Visual scripting is great for beginners and for simple tasks, but coding allows for more complex and efficient solutions. Learning to code opens up a wider range of possibilities for modding Hytale.
+
+  We will have guides on visual scripting when Hytale releases from Day 1.
+</Callout>
+
+## Should everyone trying to mod Hytale learn how to code?
+
+No one should feel like they HAVE to learn to code to make stuff in Hytale. Simon and his team have validated this time and time again with their strives in graph editors and visual scripting. You can change mob behavior, world generation, etc. all with just these tools.
+
+But if you're looking to build more complex things (from utilities to entirely custom server software) that could be used by large scale server networks and big names, you'll want to learn how to code. And that's where this guide comes in...
+
+## Okay, I'm interested. What's to come?
+
+Over the course of these next several lessons you'll learn the basics of coding, how to read documentation, and how to find resources to help you learn more on your own.
+
+The guides themselves will take a very big "bird's-eye view" approach to things and provide links to resources to do the actual coding. This is done because, quite frankly, enough resources exist on how to learn this stuff, it's just the act of finding the right stuff on Google that can be hard. Learning to be able to code without guidance is the goal. The Hytale Modding community is always there to help you, but to become a truly well rounded developer, you'll have to pick up a lot of this stuff just by reading from resources.
+
+<Callout type="info" title="Finding Resources">
+  We have created a small Java Basics series to help you get started with the language itself, but beyond that, you'll be expected to find your own resources to learn more. We recommend sites like [w3schools](https://www.w3schools.com/java/) and [GeeksforGeeks](https://www.geeksforgeeks.org/java/) as great starting points.
+</Callout>
+
+Our goal is to teach you how to Mod Hytale, and that will always be our goal. This is the reason we can't teach you everything about Java or programming in general. Instead, we want to give you the tools to be able to learn on your own, so you can continue to grow as a developer even after you've completed our guides.
+
+## Any closing thoughts?
+
+Remember, learning to code is hard. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come. Happy coding!
diff --git a/content/docs/cs-CZ/guides/plugin/block-components.mdx b/content/docs/cs-CZ/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/cs-CZ/guides/plugin/browsing-serverjar.mdx b/content/docs/cs-CZ/guides/plugin/browsing-serverjar.mdx
new file mode 100644
index 00000000..240ed19a
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/browsing-serverjar.mdx
@@ -0,0 +1,111 @@
+---
+title: Browsing the server.jar code
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
+---
+
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
+
+## Why?
+
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
+
+- Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
+  one of these:
+
+  - `python -m venv .venv`
+  - `python3 -m venv .venv` (Linux)
+  - `py -3.13 -m venv .venv` (Windows)
+
+  In the last one, specifying the version is recommended if you have multiple Pythons installed.
+
+- Activate the virtual environment:
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
+  - Linux/Mac: `source .venv/bin/activate`
+  - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
+
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
+  - `pip install -r requirements.txt`
+
+- Install these dependencies and ensure they are on PATH:
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
+  - `java` you need JDK 25 or newer
+  - `jar` (comes with JDK inside the bin folder)
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
+
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
+
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+
+Then run this:
+
+```shell
+python run.py setup
+```
+
+What will it do:
+
+- copy the HytaleServer.jar into `work/download`
+  - (on Windows) fix `META-INF/license` name collision
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
+- set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
+
+You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
+you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
+
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
+![_readme_images/img.png](/assets/reload-maven.png)\
+It is located in the "m" icon on the right side:\
+![_readme_images/m.png](/assets/maven.png)\
+If you don't see it, enable it under View -> Tool Windows -> Maven.\
+![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
diff --git a/content/docs/cs-CZ/guides/plugin/build-and-test.mdx b/content/docs/cs-CZ/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/cs-CZ/guides/plugin/chat-formatting.mdx b/content/docs/cs-CZ/guides/plugin/chat-formatting.mdx
new file mode 100644
index 00000000..c967fc0f
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/chat-formatting.mdx
@@ -0,0 +1,199 @@
+---
+title: Formatting the chat
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+![chat format example](/assets/guides/chat-example.png)
+
+The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
+You can cancel this event as well as modify the content and the formatter.
+
+## Manual Formatting (Standard Approach)
+
+```java
+public class ChatFormatter {
+
+  public static void onPlayerChat(PlayerChatEvent event) {
+    PlayerRef sender = event.getSender();
+    if(event.getContent().equalsIgnoreCase("poo")) {
+      event.setCancelled(true);
+      sender.sendMessage(Message.raw("Hey, you cannot say that!").color(Color.RED));
+    }
+
+    if(event.getContent().equalsIgnoreCase("you stink")) {
+      event.setContent("i stink");
+    }
+
+    event.setFormatter((playerRed, message) ->
+        Message.join(
+            Message.raw("[COOL] ").color(Color.RED),
+            Message.raw(sender.getUsername()).color(Color.YELLOW),
+            Message.raw(" : " + message).color(Color.PINK)
+        ));
+
+  }
+}
+```
+
+The formatter is the following interface:
+
+```java
+  public interface Formatter {
+    @Nonnull
+    Message format(@Nonnull PlayerRef playerRef, @Nonnull String message);
+  }
+}
+```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/cs-CZ/guides/plugin/client-inputs-reference.mdx b/content/docs/cs-CZ/guides/plugin/client-inputs-reference.mdx
new file mode 100644
index 00000000..a9f2f085
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/client-inputs-reference.mdx
@@ -0,0 +1,94 @@
+---
+title: "Packets: Client-to-Server Reference"
+description: Complete reference for every packet the client can send to the server.
+authors:
+  - name: Vibe Theory & musava
+    url: https://discord.com/users/145420279294722048
+---
+
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/cs-CZ/guides/plugin/creating-block.mdx b/content/docs/cs-CZ/guides/plugin/creating-block.mdx
new file mode 100644
index 00000000..07b909ad
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/creating-block.mdx
@@ -0,0 +1,101 @@
+---
+title: Creating custom blocks
+description: Learn how to create custom blocks for your Hytale mod.
+authors:
+  - name: Flo_12344
+    url: https://flotterstudio.com
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating custom blocks requires enabling asset packs and organizing your files properly.
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" />
+      </Folder>
+
+      <Folder name="Languages" defaultOpen>
+        <Folder name="en-US" />
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" />
+
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="my_new_block" defaultOpen>
+          <File name="model.blockymodel" />
+        </Folder>
+      </Folder>
+
+      <Folder name="BlockTextures" defaultOpen>
+        <File name="texture.png" />
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+3. Add translations in `Server/Languages/en-US/items.lang`:
+
+```
+my_new_block.name = My New Block
+my_new_block.description = My Description
+```
+
+## Basic Cube Block
+
+Create `Server/Item/Items/my_new_block.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "items.my_new_block.name",
+    "Description": "items.my_new_block.description"
+  },
+  "Id": "My_New_Block",
+  "MaxStack": 100,
+  "Icon": "Icons/ItemsGenerated/my_new_block.png",
+  "Categories": [
+    "Blocks.Rocks"
+  ],
+
+  "PlayerAnimationsId": "Block",
+  "Set": "Rock_Stone",
+  "BlockType": {
+    "Material": "Solid",
+    "DrawType": "Cube",
+    "Group": "Stone",
+    "Flags": {},
+    "Gathering": {
+      "Breaking": {
+        "GatherType": "Rocks",
+        "ItemId": "my_new_block"
+      }
+    },
+    "BlockParticleSetId": "Stone",
+    "Textures": [
+      {
+        "All": "BlockTextures/my_new_block.png"
+      }
+    ],
+    "ParticleColor": "#aeae8c",
+    "BlockSoundSetId": "Stone",
+    "BlockBreakingDecalId": "Breaking_Decals_Rock"
+  },
+  "ResourceTypes": [
+    {
+      "Id": "Rock"
+    }
+  ]
+}
+```
+
+Ensure all referenced files exist in their respective folders, and the paths are correct.
diff --git a/content/docs/cs-CZ/guides/plugin/creating-commands.mdx b/content/docs/cs-CZ/guides/plugin/creating-commands.mdx
new file mode 100644
index 00000000..f9881d9d
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/creating-commands.mdx
@@ -0,0 +1,421 @@
+---
+title: Creating Commands
+description: Learn how to create custom commands for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
+---
+
+In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
+
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
+
+To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
+
+You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
+
+You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
+
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
+```java
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType()); // also a component
+    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+    TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+    player.sendMessage(Message.raw("Player#getUuid() : " + player.getUuid())); // returns UUID from UUIDComponent
+    player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+    player.sendMessage(Message.raw("equal : " + player.getUuid().equals(component.getUuid()))); // they're both the same
+    player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+  }
+
+}
+```
+
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
+## Registering the Command
+
+For any command
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // One way to add commands
+        this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
+    }
+}
+```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/cs-CZ/guides/plugin/creating-configuration-file.mdx b/content/docs/cs-CZ/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/cs-CZ/guides/plugin/creating-events.mdx b/content/docs/cs-CZ/guides/plugin/creating-events.mdx
new file mode 100644
index 00000000..ea7abdc2
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/creating-events.mdx
@@ -0,0 +1,90 @@
+---
+title: Creating Events
+description: Learn how to create custom events for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: EllieAU
+    url: https://ellie.au
+---
+
+## Event Class
+
+You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+
+Example plugin when a player is ready (joins a server):
+
+```java
+
+public class ExampleEvent {
+
+    public static void onPlayerReady(PlayerReadyEvent event) {
+        Player player = event.getPlayer();
+        player.sendMessage(Message.raw("Welcome " + player.getDisplayName()));
+    }
+
+}
+```
+
+## Registering the Event
+
+You need to register all events you make in the Main plugin class, usually in the `setup` function.
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        this.getEventRegistry().registerGlobal(PlayerReadyEvent.class, ExampleEvent::onPlayerReady);
+    }
+}
+```
+
+## ECS Event Classes
+
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
+
+```java
+class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent.Pre> {
+    public ExampleCancelCraft() {
+        super(CraftRecipeEvent.Pre.class);
+    }
+
+    @Override
+    public void handle(int index,
+                       @NonNullDecl ArchetypeChunk<EntityStore> archetypeChunk,
+                       @NonNullDecl Store<EntityStore> store,
+                       @NonNullDecl CommandBuffer<EntityStore> commandBuffer,
+                       @NonNullDecl CraftRecipeEvent.Pre craftRecipeEvent) {
+        CraftingRecipe recipe = craftRecipeEvent.getCraftedRecipe();
+        if (recipe.getInput() != null) {
+            for (MaterialQuantity mq : recipe.getInput()) {
+                if (Objects.equals(mq.getItemId(), "Ingredient_Fibre")) {
+                    craftRecipeEvent.setCancelled(true);
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Archetype.empty();
+    }
+}
+```
+
+## Registering ECS Events
+
+You will need to register the system in your plugin:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        this.getEntityStoreRegistry().registerSystem(new ExampleCancelCraft());
+    }
+}
+```
diff --git a/content/docs/cs-CZ/guides/plugin/customizing-camera-controls.mdx b/content/docs/cs-CZ/guides/plugin/customizing-camera-controls.mdx
new file mode 100644
index 00000000..e98c7777
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/customizing-camera-controls.mdx
@@ -0,0 +1,170 @@
+---
+title: Customizing Camera Controls
+description: Intro to custom camera modding.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+## The Basics
+
+Hytale provides great camera customizability! Heres the essentials to get started.
+
+Camera is controlled by sending a `SetServerCamera` packet with `ServerCameraSettings`:
+
+```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)
+);
+```
+
+This gives you a simple third-person camera. The presets below show more complete configurations.
+
+**Reset to default:**
+
+```java
+playerRef.getPacketHandler().writeNoCache(
+    new SetServerCamera(ClientCameraView.Custom, false, null)
+);
+```
+
+---
+
+## Camera Presets
+
+### Top-Down (RTS/ARPG Style)
+
+_Source: `com.hypixel.hytale.server.core.command.commands.player.camera.PlayerCameraTopdownCommand`_
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.distance = 20.0f;
+settings.displayCursor = true;
+settings.isFirstPerson = false;
+settings.movementForceRotationType = MovementForceRotationType.Custom;
+// Align movement with camera yaw (horizontal rotation only)
+settings.movementForceRotation = new Direction(-0.7853981634f, 0.0f, 0.0f);  // 45° left
+settings.eyeOffset = true;
+settings.positionDistanceOffsetType = PositionDistanceOffsetType.DistanceOffset;
+settings.rotationType = RotationType.Custom;
+settings.rotation = new Direction(0.0f, -1.5707964f, 0.0f);  // Look straight down
+settings.mouseInputType = MouseInputType.LookAtPlane;
+settings.planeNormal = new Vector3f(0.0f, 1.0f, 0.0f);       // Ground plane
+```
+
+### Side-Scroller (2D Platformer Style)
+
+_Source: `com.hypixel.hytale.server.core.command.commands.player.camera.PlayerCameraSideScrollerCommand`_
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.distance = 15.0f;
+settings.displayCursor = true;
+settings.isFirstPerson = false;
+settings.movementForceRotationType = MovementForceRotationType.Custom;
+settings.movementMultiplier = new Vector3f(1.0f, 1.0f, 0.0f);  // Lock Z-axis
+settings.eyeOffset = true;
+settings.positionDistanceOffsetType = PositionDistanceOffsetType.DistanceOffset;
+settings.rotationType = RotationType.Custom;
+settings.mouseInputType = MouseInputType.LookAtPlane;
+settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
+```
+
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
+## Common Settings Explained
+
+### Position & Rotation
+
+- **`positionLerpSpeed`** (0.0-1.0): How smoothly the camera follows the player. Lower = smoother but slower response.
+- **`rotationLerpSpeed`** (0.0-1.0): How smoothly the camera rotates. Lower = smoother but slower response.
+- **`distance`**: Camera distance from player. Higher = zoomed out more.
+- **`rotation`**: Camera angle as `Direction(yaw, pitch, roll)` in radians.
+- **`rotationType`**: How rotation is calculated. `RotationType.Custom` uses your `rotation` value.
+
+### Movement Alignment
+
+- **`movementForceRotationType`**:
+- `MovementForceRotationType.AttachedToHead` = movement follows where player looks
+- `MovementForceRotationType.Custom` = use `movementForceRotation` value
+- **`movementForceRotation`**: When using `Custom`, this sets the direction for W/S movement. Match yaw with camera but keep pitch at 0.
+
+### Input & Display
+
+- **`displayCursor`**: Show/hide mouse cursor.
+- **`mouseInputType`**:
+- `MouseInputType.LookAtPlane` = mouse moves cursor on a plane (good for top-down)
+- `MouseInputType.LookAtTarget` = mouse rotates camera
+- **`planeNormal`**: For `LookAtPlane`, defines which plane the mouse moves on. `(0,1,0)` = ground plane.
+
+### Advanced
+
+- **`positionDistanceOffsetType`**:
+- `DistanceOffset` = simple distance offset
+- `DistanceOffsetRaycast` = prevents camera clipping through walls
+- **`eyeOffset`**: Offset camera from player's eye position.
+- **`movementMultiplier`**: Scale movement on each axis. `(1,1,0)` = lock Z-axis for 2D movement.
+
+---
+
+## Imports
+
+```java
+import com.hypixel.hytale.protocol.ClientCameraView;
+import com.hypixel.hytale.protocol.Direction;
+import com.hypixel.hytale.protocol.MouseInputType;
+import com.hypixel.hytale.protocol.MovementForceRotationType;
+import com.hypixel.hytale.protocol.PositionDistanceOffsetType;
+import com.hypixel.hytale.protocol.RotationType;
+import com.hypixel.hytale.protocol.ServerCameraSettings;
+import com.hypixel.hytale.protocol.Vector3f;
+import com.hypixel.hytale.protocol.packets.camera.SetServerCamera;
+```
+
+---
+
+## Tips
+
+- **Zoom:** Adjust `distance` (higher = further out)
+- **Smoothness:** `positionLerpSpeed` and `rotationLerpSpeed` control how quickly the camera catches up to its target
+- **Wall clipping:** Use `PositionDistanceOffsetType.DistanceOffsetRaycast`
+- **Lock camera:** Set `isLocked = true` in the packet to prevent player changes
+- **2D movement:** Set `movementMultiplier` to zero out an axis
+- **Isometric cameras:** Always set `movementForceRotation` to match camera yaw for proper movement alignment
+- **Angle calculations:** Use `Math.toRadians(degrees)` or `degrees * Math.PI / 180.0` to convert degrees to radians
+
+---
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/cs-CZ/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/cs-CZ/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/cs-CZ/guides/plugin/instances.mdx b/content/docs/cs-CZ/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/cs-CZ/guides/plugin/inventory-management.mdx b/content/docs/cs-CZ/guides/plugin/inventory-management.mdx
new file mode 100644
index 00000000..e38c644f
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/inventory-management.mdx
@@ -0,0 +1,125 @@
+---
+title: Inventory Management
+description: Learn how to manage player inventories in your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+---
+
+In this guide, you'll learn how to manage player inventories in your Hytale mod.
+
+## Accessing the Player Inventory
+
+To access the Inventory of a `Player`, you can use the `getInventory()` method which returns the `Inventory` object.
+
+```java
+Inventory inventory = player.getInventory();
+```
+
+## Opening Inventories
+
+You can open different types of inventories, these inventories are known as "Pages". You can also add custom pages, this will be covered in a guide later on.
+
+You can use the `Page` enum to reference existing inventories, currently the following pages are available:
+
+- `Page.None`
+- `Page.Bench`
+- `Page.Inventory`
+- `Page.ToolsSettings`
+- `Page.Map`
+- `Page.MachinimaEditor`
+- `Page.ContentCreation`
+- `Page.Custom`
+
+```java
+PageManager pageManager = player.getPageManager();
+Store<EntityStore> store = player.getWorld().getEntityStore().getStore();
+pageManager.setPage(player.getReference(), store, Page.Inventory);
+```
+
+## `ItemStack` Class
+
+You can create and manipulate items in a player's inventory using the `ItemStack` class. This class represents a stack of items, and provides methods for managing the quantity and type of items in the stack.
+
+### Creating an ItemStack
+
+To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
+
+```java
+ItemStack item = new ItemStack("Stone");
+ItemStack withQuantity = new ItemStack("Stone", 64);
+```
+
+#### Adding custom metadata
+
+You can also add custom metadata to a `ItemStack` by passing a `BsonDocument` when creating it.
+
+```java
+BsonDocument metadata = new BsonDocument();
+metadata.append("customData", new BsonString("value"));
+ItemStack item = new ItemStack("Stone", 64, metadata);
+```
+
+### Setting a durability
+
+```java
+ItemStack stackWithDurability = new ItemStack(
+    "DiamondSword", // itemId
+    1,              // quantity
+    100.0,          // durability
+    100.0,          // maxDurability
+    metadata        // metadata (optional)
+);
+```
+
+## Getting the `ItemContainer`
+
+The `Inventory` class provides methods to get multiple `ItemContainer` objects, like:
+
+- `.getStorage()`
+- `.getArmor()`
+- `.getBackpack()`
+- `.getHotbar()`
+- `.getUtility()`
+
+There are also combined methods like:
+
+- `.getCombinedEverything()`
+- `.getCombinedArmorHotbarStorage()`
+- `.getCombinedBackpackStorageHotbar()`
+- `.getCombinedHotbarFirst()`
+- `.getCombinedStorageFirst()`
+- `.getCombinedArmorHotbarUtilityStorage()`
+- `.getCombinedHotbarUtilityConsumableStorage()`
+
+## Adding `ItemStack` objects to the Inventory
+
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
+
+```java
+Inventory inventory = player.getInventory();
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
+```
+
+Or you can specify a certain slot to add it to:
+
+```java
+storageContainer.addItemStackToSlot((short) 4, stack)
+```
+
+## Removing `ItemStack` objects from the Inventory
+
+To remove an `ItemStack` from a player's inventory, you can use the `removeItemStack()` method of the `Inventory` class.
+
+```java
+Inventory inventory = player.getInventory();
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
+```
+
+Or you can specify a certain slot to remove it from:
+
+```java
+storageContainer.removeItemStackFromSlot((short) 4);
+```
diff --git a/content/docs/cs-CZ/guides/plugin/item-interaction.mdx b/content/docs/cs-CZ/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/cs-CZ/guides/plugin/listening-to-packets.mdx b/content/docs/cs-CZ/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/cs-CZ/guides/plugin/logging.mdx b/content/docs/cs-CZ/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/cs-CZ/guides/plugin/permission-management.mdx b/content/docs/cs-CZ/guides/plugin/permission-management.mdx
new file mode 100644
index 00000000..70aef22c
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/permission-management.mdx
@@ -0,0 +1,118 @@
+---
+title: Permission Management
+description: Learn how to manage permission nodes and groups in your Hytale plugin.
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: Craw
+    link: https://discord.com/users/292656109939064833
+---
+
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+
+## The `PermissionsModule` class
+
+The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+
+- Add permissions to user
+- Remove permissions from user
+- Add permissions to group (this also creates the group if it doesn't exist)
+- Remove permissions from group
+- Add user to group
+- Remove user from group
+- List all groups for a user
+- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+
+With this class you cannot:
+
+- List all defined groups
+- Remove a group
+
+### Adding Permission Nodes
+
+You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+
+```java
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addUserPermission(playerUUID, permissions);
+```
+
+### Removing Permission Nodes
+
+Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+
+```java
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeUserPermission(playerUUID, permissions);
+```
+
+### Add permissions to group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addGroupPermission(groupName, permissions);
+```
+
+### Remove permissions from group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeGroupPermission(groupName, permissions);
+```
+
+### Add user to group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addUserToGroup(playerUUID, groupName);
+```
+
+### Remove user from group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeUserFromGroup(playerUUID, groupName);
+```
+
+### List all groups for a user
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+perms.getGroupsForUser(playerUUID);
+```
+
+### Check Permission Nodes
+
+To check if a player has a specific permission node, you can use the `hasPermission` method.
+
+```java
+boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+```
+
+### Additional: Defining your own storage provider for permissions and groups
+
+Apparently we could implement our own storage provider for permissions and groups as file storage is not very reliable.
+
+First we need to define a provider class that implements PermissionProvider:
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider
+```
+
+Then we just implement the required methods using a database implementation. To force our plugin to use this new provider we just need to add to the provider list our fresh DatabasePermissionProvider.
+
+```java
+perms.getProviders().addFirst(new DatabasePermissionProvider());
+```
diff --git a/content/docs/cs-CZ/guides/plugin/player-death-event.mdx b/content/docs/cs-CZ/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/cs-CZ/guides/plugin/player-input-guide.mdx b/content/docs/cs-CZ/guides/plugin/player-input-guide.mdx
new file mode 100644
index 00000000..c9cc1419
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/player-input-guide.mdx
@@ -0,0 +1,68 @@
+---
+title: Player Input Guide
+description: Learn how to handle player input.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
+---
+
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
+
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
+
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
+
+```java
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
+        }
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
+        }
+    }
+}
+```
+
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/cs-CZ/guides/plugin/player-stats.mdx b/content/docs/cs-CZ/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/cs-CZ/guides/plugin/playing-sounds.mdx b/content/docs/cs-CZ/guides/plugin/playing-sounds.mdx
new file mode 100644
index 00000000..7ce614b8
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/playing-sounds.mdx
@@ -0,0 +1,64 @@
+---
+title: Playing Sounds
+description: Learn how to Play Sounds with your Hytale Plugin
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+In this guide, you will learn how to play sounds to a player.
+
+## Sound Indexes
+
+We currently have a lot of Sounds available to be used as a key in the AssetMap, [click here](../../server/sounds) to see the full list of available sounds.
+
+You can use the `getAssetMap()` method from the `SoundEvent` class to get the index of a specified sound:
+
+```java
+int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
+```
+
+## The Transform Component
+
+The `TransformComponent` is the component that tells Hytale where to play the sound. You can get this in multiple ways.
+
+1. Getting the Transform Component from the `Player` object
+
+```java
+TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+```
+
+2. Generating a new TransformComponent (although this is not recommended, as if your player is not close enough they won't hear the sound)
+
+```java
+Vector3d vector3d = new Vector3d(0, 0, 0); // position
+Vector3f vector3f = new Vector3f(0, 0, 0); // rotation
+TransformComponent transform = new TransformComponent(vector3d, vector3f);
+```
+
+### PlayerRef
+
+You need a Player Reference, which is a instance of `Ref<EntityStore>`. If you have the `Player` object, you can use the `getReference()` method to get a Player Reference
+
+### World
+
+You need a World reference, as the sound needs to be played inside the `execute()` method from the `World` class.
+
+### SoundCategory
+
+There is a `SoundCategory` enum that defines different sound categories, such as `Music`, `Ambient`, `SFX` and `UI`. You can use these categories to specify the type of sound you are playing.
+
+## Playing Sounds
+
+You can use the `SoundUtil` class to play sounds, using the `playSoundEvent3dToPlayer` method.
+
+```java
+int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
+World world = player.getWorld();
+EntityStore store = world.getEntityStore();
+Ref<EntityStore> playerRef = player.getReference();
+world.execute(() -> {
+    TransformComponent transform = store.getStore().getComponent(playerRef, EntityModule.get().getTransformComponentType());
+    SoundUtil.playSoundEvent3dToPlayer(playerRef, index, SoundCategory.UI, transform.getPosition(), store.getStore());
+});
+```
diff --git a/content/docs/cs-CZ/guides/plugin/send-notifications.mdx b/content/docs/cs-CZ/guides/plugin/send-notifications.mdx
new file mode 100644
index 00000000..8eafb96e
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/send-notifications.mdx
@@ -0,0 +1,48 @@
+---
+title: Sending notifications
+description: Learn how to send notifications (similar to item pickup) with your Hytale Plugin
+authors:
+  - name: BeerBag
+---
+
+## Overview
+
+In this guide, you will learn how to send notifications to players, similar to
+the notification received when picking up an item from the ground.
+
+![notification-example](/assets/guides/notification-example.png)
+
+## Structure of a Notification
+
+A notification consists of three main components:
+
+1. **Primary Message**: The main `Message` displayed in the notification.
+2. **Secondary Message**: Additional `Message`, displayed below the primary message.
+3. **Icon**: An item icon that visually represents the notification, shown on
+   the left side.
+
+## Sending Notifications
+
+You can use the `NotificationUtil` class to send notifications to players.
+You will need access to the `PacketHandler` of the player, which can be obtained
+from the `PlayerRef` using the `getPacketHandler()` method (in this example,
+we get the `PlayerRef` from the `Universe` using the player's UUID).
+
+```java
+public static void onPlayerReady(PlayerReadyEvent event) {
+    var player = event.getPlayer();
+
+    var playerRef = Universe.get().getPlayer(player.getUuid());
+    var packetHandler = playerRef.getPacketHandler();
+
+    var primaryMessage = Message.raw("THIS WORKS!!!").color("#00FF00");
+    var secondaryMessage = Message.raw("This is the secondary message").color("#228B22");
+    var icon = new ItemStack("Weapon_Sword_Mithril", 1).toPacket();
+
+    NotificationUtil.sendNotification(
+        packetHandler,
+        primaryMessage,
+        secondaryMessage,
+        (ItemWithAllMetadata) icon);
+}
+```
diff --git a/content/docs/cs-CZ/guides/plugin/setting-up-env.mdx b/content/docs/cs-CZ/guides/plugin/setting-up-env.mdx
new file mode 100644
index 00000000..8115e634
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/setting-up-env.mdx
@@ -0,0 +1,170 @@
+---
+title: Setting Up Your Development Environment
+description: Learn how to set up your development environment for modding Hytale.
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
+This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
+
+## Prerequisites
+
+Before we begin, make sure you have:
+
+- A computer running Windows 10/11, macOS, or Linux
+- At least 8GB of RAM
+- 10GB of free disk space
+- Administrative privileges on your system
+
+## Required Software
+
+### 1. Java Development Kit (JDK)
+
+Hytale modding requires Java 25 or later. We recommend using OpenJDK.
+
+#### Windows
+
+1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
+2. Run the installer with default settings
+3. Verify installation by opening Command Prompt and running:
+
+```bash
+java -version
+```
+
+#### macOS
+
+```bash
+# Using Homebrew
+brew install openjdk@25
+```
+
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
+#### Linux (Ubuntu/Debian)
+
+```bash
+sudo apt update
+sudo apt install openjdk-25-jdk
+```
+
+### 2. Integrated Development Environment (IDE)
+
+We recommend IntelliJ IDEA Community Edition for Hytale modding.
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+
+1. Visit the official website: https://maven.apache.org/download.cgi
+2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `apache-maven-3.9.12/bin/` folder to your PATH
+
+You can now try the command `mvn -version` to verify Maven is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+## Setting Up Your Workspace
+
+### 1. Clone the Plugin Template
+
+Instead of creating an empty directory, we'll use the official Hytale plugin template:
+
+```bash
+# Clone the template repository
+git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
+cd MyFirstMod
+```
+
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
+
+1. Open IntelliJ IDEA
+2. Click "Open" and navigate to your `MyFirstMod` directory
+3. IntelliJ will automatically detect it as a Maven project
+4. Wait for the project to index and dependencies to download
+
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
+## Next Steps
+
+Now that you have your development environment set up with the plugin template:
+
+1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+2. **Explore the code structure** - Familiarize yourself with the template's organization
+3. **Start modding** - Begin writing your first Hytale plugin!
+
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
+
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/cs-CZ/guides/plugin/spawning-entities.mdx b/content/docs/cs-CZ/guides/plugin/spawning-entities.mdx
new file mode 100644
index 00000000..e12c0aea
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/spawning-entities.mdx
@@ -0,0 +1,120 @@
+---
+title: Spawning Entities
+description: Learn how to spawn Entities in Hytale
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+In this guide, you will learn how to spawn entities in Hytale. It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding with this guide. You can find the ECS guide [here](./ecs).
+
+## Getting the World Object
+
+You need to first get the `World` object before proceeding with spawning entities. You can get this object in a few ways:
+
+### Using the `Player` Object
+
+You can use the `Player` object to get the `World` object by calling the `getWorld()` method on the `Player` instance.
+
+```java
+World world = player.getWorld();
+```
+
+### Using the `Universe` Class
+
+You can use the `Universe` class to get the `World` object by calling the `getWorld(string UUID)` method on the `Universe` instance.
+
+```java
+World world = Universe.get().getWorld("your-world-uuid");
+```
+
+Once you have the world object, you need to get a instance of `Store<EntityStore>`, you can do so by:
+
+```java
+Store<EntityStore> store = world.getEntityStore().getStore();
+```
+
+## Creating Entities
+
+Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+
+<Callout type="warning">
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
+
+  ```java
+  world.execute(() -> {
+      // run all the code below in this context
+  })
+  ```
+</Callout>
+
+Let's start by creating a blank holder:
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+```
+
+## Getting a Model
+
+You now need a model for your Entity. You can find a list of all entities [here](../../server/entities), we're going to use the Minecart entity for this example:
+
+```java
+ModelAsset modelAsset = ModelAsset.getAssetMap().getAsset("Minecart");
+Model model = Model.createScaledModel(modelAsset, 1.0f);
+```
+
+### The Transform Component
+
+The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
+
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
+
+```java
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
+```
+
+2. Generating a new TransformComponent
+
+```java
+Vector3d vector3d = new Vector3d(0, 0, 0); // position
+Vector3f vector3f = new Vector3f(0, 0, 0); // rotation
+TransformComponent transform = new TransformComponent(vector3d, vector3f);
+```
+
+## Adding Components to our Entity
+
+Now we need to add all the components we made above to our entity, here's all the components we need to add one by one:
+
+```java
+
+holder.addComponent(TransformComponent.getComponentType(), new TransformComponent(vector3d, new Vector3f(0, 0, 0)));
+holder.addComponent(PersistentModel.getComponentType(), new PersistentModel(model.toReference()));
+holder.addComponent(ModelComponent.getComponentType(), new ModelComponent(model));
+holder.addComponent(BoundingBox.getComponentType(), new BoundingBox(model.getBoundingBox()));
+holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+holder.addComponent(Interactions.getComponentType(), new Interactions()); // you need to add interactions here if you want your entity to be interactable
+```
+
+### Ensuring Hytale's Components are present
+
+These act as "configuration" or "default" components that Hytale expects to be present on all entities.
+
+```java
+holder.ensureComponent(UUIDComponent.getComponentType());
+holder.ensureComponent(Interactable.getComponentType()); // if you want your entity to be interactable
+```
+
+## Spawning the Entity
+
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
+
+```java
+store.addEntity(holder, AddReason.SPAWN);
+```
diff --git a/content/docs/cs-CZ/guides/plugin/spawning-npcs.mdx b/content/docs/cs-CZ/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/cs-CZ/guides/plugin/store-persistant-data.mdx b/content/docs/cs-CZ/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/cs-CZ/guides/plugin/teleporting-players.mdx b/content/docs/cs-CZ/guides/plugin/teleporting-players.mdx
new file mode 100644
index 00000000..57cee77f
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/teleporting-players.mdx
@@ -0,0 +1,26 @@
+---
+title: Teleporting the player
+description: Learn how to teleport the player.
+---
+
+To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
+Next, we get the entity store and make a `Teleport` object.
+We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+
+```java
+public static void teleportPlayer(Player player, int x, int y, int z) {
+        World world = player.getWorld();
+        if (world == null) return;
+        world.execute(() -> {
+            if (player.getReference() == null) return;
+            Store<EntityStore> store = player.getReference().getStore();
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
+
+            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
+        });
+
+}
+```
diff --git a/content/docs/cs-CZ/guides/plugin/text-hologram.mdx b/content/docs/cs-CZ/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/cs-CZ/guides/plugin/ui.mdx b/content/docs/cs-CZ/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/cs-CZ/guides/plugin/world-gen.mdx b/content/docs/cs-CZ/guides/plugin/world-gen.mdx
new file mode 100644
index 00000000..4c23b0c9
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/world-gen.mdx
@@ -0,0 +1,143 @@
+---
+title: World Generation System
+description: Learn how to create custom world generation features for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+---
+
+# Overview
+
+This section covers Hytale's procedural world generation systems that creates environments, biomes, and structures dynamically as players explore the world.
+
+Hytale’s world generation is organized into three interconnected systems:
+
+- **Zones** - Large-scale regions that define overall world structure
+- **Biomes** - Terrain characteristics and environmental properties within zones
+- **Caves** - Underground structures and networks generated within zones
+
+These systems work together to create a rich, varied world with smooth transitions and coherent regional themes.
+
+## Getting Started
+
+1. Zone System - Large regions
+2. Biome System - Terrain and environment within zones
+3. Cave System - Underground structures and networks within zones
+
+## Implementation Details
+
+### Zone Lookup and Generation
+
+```java
+
+// Get zone at position
+ZonePatternGenerator zoneGen = /* world generator */;
+ZoneGeneratorResult zoneResult = zoneGen.generate(seed, x, z);
+Zone zone = zoneResult.getZone();
+
+// Get biome within zone
+BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
+Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
+
+// Check for caves in zone
+CaveGenerator caveGen = zone.caveGenerator();
+if (caveGen != null) {
+    CaveType[] caveTypes = caveGen.getCaveTypes();
+    // Generate caves as needed
+}
+```
+
+### Creating a Custom Zone
+
+```java
+// Configure zone discovery
+ZoneDiscoveryConfig discovery = new ZoneDiscoveryConfig(
+    true,                           // Show notification
+    "Custom Zone",                  // Display name
+    "zone.forest.discover",         // Sound event
+    "icons/forest.png",             // Icon
+    true,                           // Major zone
+    5.0f, 2.0f, 1.5f                // Duration, fade in, fade out
+);
+
+// Create biome pattern
+IPointGenerator biomePoints;
+IWeightedMap<TileBiome> tileBiomes;
+CustomBiome[] customBiomes;
+
+BiomePatternGenerator biomeGen = new BiomePatternGenerator(
+    biomePoints,
+    tileBiomes,
+    customBiomes
+);
+
+// Create cave configuration
+CaveType[] caveTypes; // cave definitions
+CaveGenerator caveGen = new CaveGenerator(caveTypes);
+
+// Assemble the zone
+Zone customZone = new Zone(
+    100,                    // Unique ID
+    "new_custom_zone",      // Internal name
+    discovery,              // Discovery config
+    caveGen,                // Cave generator
+    biomeGen,               // Biome pattern
+    uniquePrefabs           // Unique structures
+);
+```
+
+## System Integration
+
+### Zone & Biome Integration
+
+Each zone defines its own biome pattern:
+
+```java
+Zone zone = zoneGen.generate(seed, x, z).getZone();
+BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
+Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
+```
+
+### Zone & Cave Integration
+
+Each zone defines it's own cave patterns:
+
+```java
+Zone zone = /* ... */;
+CaveGenerator caveGen = zone.caveGenerator();
+if (caveGen != null) {
+    // This zone has caves
+    CaveType[] types = caveGen.getCaveTypes();
+}
+```
+
+### Biome & Cave Integration
+
+Caves use biome masks for placement control:
+
+```java
+// Cave type with biome restrictions
+Int2FlagsCondition biomeMask = caveType.getBiomeMask();
+int biomeId = biome.getId();
+int flags = biomeMask.eval(biomeId);
+
+// Check if cave can generate in this biome
+if (CaveBiomeMaskFlags.canGenerate(flags)) {
+    // Generate cave
+}
+```
+
+### Border Transitions
+
+All systems respect zone boundaries:
+
+```java
+ZoneGeneratorResult result = zoneGen.generate(seed, x, z);
+double borderDistance = result.getBorderDistance();
+
+// Fade custom biomes near borders
+if (borderDistance < customBiome.getFadeContainer().getMaskFadeSum()) {
+    double factor = customBiome.getFadeContainer().getMaskFactor(result);
+    // Apply fading
+}
+```
diff --git a/content/docs/cs-CZ/guides/prefabs.mdx b/content/docs/cs-CZ/guides/prefabs.mdx
new file mode 100644
index 00000000..08404b30
--- /dev/null
+++ b/content/docs/cs-CZ/guides/prefabs.mdx
@@ -0,0 +1,92 @@
+---
+title: Prefabs
+description: Documentation about Prefabs in Hytale.
+icon: Box
+authors:
+  - name: Ben Cressman
+    url: https://bencres.dev
+---
+
+# Introduction
+
+Prefabs are Hytale's way of creating reusable structures.
+
+There are a few fundamental concepts to understand about prefabs:
+
+- Users interact with prefabs via a prefab editing world.
+- Prefabs the physical structures in the game world, and are saved as JSON files.
+
+## How to Create a Prefab
+
+Be sure to check the Known Issues section at the end of this guide if you encounter any problems.
+
+1. `/editprefab new <world name>` to create a new prefab editing world: `/editprefab new my_prefab_world`
+   - Note that `my_prefab` is the name of the _world_, not the prefab itself. Worlds can contain multiple prefabs.
+2. Build whatever you want in the prefab editing world.
+3. Use the selection brush to select the area you want to save as a prefab.
+4. `/prefab save` to save the structure as a prefab.
+5. `/editprefab exit` to exit the prefab editing world.
+6. Using the Paste brush, press 'e' on your keyboard to select the prefab you just created. It will be in the "server" dropdown, which can be selected from the top right of the menu.
+   - You can also select it with `/prefab list` and selecting the prefab you just created.
+
+There is a lot more that you can do with prefabs; this is just the basic flow. Keep reading for more information.
+
+## Commands
+
+There are two main commands for prefabs, `/prefab` and `/editprefab`.
+
+This list does not cover the various options for each command. You can use the `--help` flag at the end of any command to see the available options, e.g. `/prefab save --help`, or use `/help` in game and find the `prefab` and `editprefab` commands.
+
+### `/prefab`
+
+This command allows the user to interact with an existing prefab's file.
+
+Subcommands:
+
+- `save`
+  - Saves the prefab to the file system.
+- `load`
+  - Loads the prefab into the game.
+- `delete`
+  - Deletes the prefab from the file system.
+- `list`
+  - Lists all prefabs in the file system.
+
+### `/editprefab`
+
+The `/editprefab` command is used to create or edit the physical structure in the game the prefab is holding.
+
+Subcommands:
+
+- `exit`
+  - Exits the current prefab editing world.
+- `load`
+  - Creates a new prefab editing world to paste an existing prefab into.
+- `new`
+  - Creates a new prefab editing world to create a new prefab from scratch.
+- `select`
+  - Selects the area of the prefab the user is looking at (within 200 blocks).
+- `save`
+  - Saves the current prefab using the existing area, or the currently selected area.
+- `saveui`
+  - Opens the save UI for the current world, allowing the user to interact with all prefabs that are in the world.
+- `kill`
+  - Despawn all entities in the currently selected prefab.
+- `saveas`
+  - Save the selected prefab into a new file.
+- `setbox`
+  - Set the bounding box of the currently selected prefab.
+- `info`
+  - General information about the currently selected prefab.
+- `tp`
+  - Opens the teleport UI to teleport to a prefab in the current editing world.
+- `modified`
+  - Lists all modified prefabs with unsaved changes in the current editing world.
+
+# Known Issues
+
+- After saving edits to an existing prefab, the prefab does not reflect the changes in the game.
+  - Workaround: exit and re-enter the world.
+- When pasting a prefab, the prefab is not always shown accurately.
+  - Workaround: hit 't' on your keyboard to toggle the material being shown; usually at least one view is accurate.
+- `/prefab delete` errors with `Assert not in thread`.
diff --git a/content/docs/cs-CZ/index.mdx b/content/docs/cs-CZ/index.mdx
new file mode 100644
index 00000000..e09ace85
--- /dev/null
+++ b/content/docs/cs-CZ/index.mdx
@@ -0,0 +1,19 @@
+---
+title: Introduction
+description: Necessary knowledge for modding Hytale.
+---
+
+Hytale is a voxel-based sandbox RPG game by **Hypixel Studios**, as described on the [Hytale website](https://hytale.com/):
+
+> Set out on an adventure built for both creation and play. Hytale blends the freedom
+> of a sandbox with the momentum of an RPG: explore a procedurally generated world full
+> of dungeons, secrets, and a variety of creatures, then shape it block by block.
+
+Hytale has been built from the ground up with modding and user-generated content in mind.
+The goal of **Hytale Modding** is to provide an excellent resource such that anybody
+is able to mod Hytale for themselves, regardless of skill level or specialization.
+
+It is important to note that modding Hytale is not restricted to programming plugins.
+Programming, visual scripting, texturing, 3D modelling, modifying assets, etc. are all modding.
+
+<u>In Hytale, anyone can be a modder.</u>
diff --git a/content/docs/cs-CZ/official-documentation/npc-doc.mdx b/content/docs/cs-CZ/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/cs-CZ/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/cs-CZ/publishing/builtbybit.mdx b/content/docs/cs-CZ/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/cs-CZ/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/cs-CZ/publishing/curseforge.mdx b/content/docs/cs-CZ/publishing/curseforge.mdx
new file mode 100644
index 00000000..d97327d5
--- /dev/null
+++ b/content/docs/cs-CZ/publishing/curseforge.mdx
@@ -0,0 +1,71 @@
+---
+title: CurseForge
+description: Learn how to publish your mod to CurseForge
+---
+
+CurseForge is a mod hosting platform, allowing you to share your Hytale mods and creations with players via our website and app.
+
+## 1. Create CurseForge Account
+
+First, [visit our sign-in page](https://curseforge.com/api/v1/auth/login?returnUrl=https://www.curseforge.com/) and either log in to an existing account or click “Create an account”.
+
+This can be done using any Google, Discord, GitHub or Twitch account.
+
+## 2. Create a Project
+
+Now that you're logged in, you can visit our Author Console and navigate to the Projects tab, then click “Create a Project”, either in the sidebar or at the top of the page.
+
+![CurseForge Author Page](/assets/guides/curseforge_author_page.png)
+
+This will then take you to the [project creation](https://authors.curseforge.com/#/projects/create/choose-game) flow. First, select your game (in this case, Hytale) for and the page will be updated with new fields waiting for your inputs. Please see our
+
+[Moderation Policies](https://support.curseforge.com/en/support/solutions/articles/9000197279-moderation-policies#:~:text=General%20CurseForge%20Moderation%20Policies,-Policy\&text=The%20description%20can%20include%20descriptive,the%20game%22%20is%20not%20enough) articles for more information about what is and isn't allowed when creating a new project. Below are the fields along with their descriptions:
+
+- **Name:** This is the title of your project. It should be unique to your project. If the name is already taken, it will be rejected.
+- **Summary:** This is a short blurb about the mod that will show up in the project listings
+- **Description:** This is the longer explanation of what your mod does/adds. Make sure you clearly elaborate on your project. We will reject your project if the description is not grammatically correct or if it does not sufficiently describe the project you are creating. This can be edited later. Note: All titles and descriptions must be in English.
+- **Project License:** This is a drop-down field that contains the most common licenses used in modding games. Research the license type you want to use, including its pros and cons. You can also choose to use a Custom License at the bottom of the dropdown list and enter any text you want.
+- **Class:** This is the root category for your project. Ensure you select the correct one, as it may impact supported file types and app support in CurseForge.
+  - For Hytale, there are four types of Class:
+    - Mods
+      - This is the class that contains both Asset Packs and Plugins, and you should upload either here.
+    - Worlds
+    - Prefabs
+    - Bootstrap
+      - This is the class that contains all Early Plugins.
+- **Main Category:** This is the primary category into which your project will be sorted.
+- **Additional categories:** You can add up to 4 of these. Your project will also show up in lists where people are searching for these types of mods. Be careful, though, if you just add categories that have nothing to do with your mod, we may send it back to you for changes.
+- **Logo Image:** A unique icon to identify your project by.
+
+## 3. Upload a File
+
+Once you've set up your project and filled in the above information, you now need to upload a file to your project for it to enter the moderation queue. To do this, visit the “Files” tab in your Author Console page.
+
+![CurseForge Add Project](/assets/guides/curseforge_add_project.png)
+
+Then, click on “Add File” and upload your mod's file, entering any additional information or meta you wish to include regarding this file.
+
+The file format will depend on the class you select.
+
+### For Plugins
+
+If you're uploading a plugin for Hytale, please make sure you select the "Mods" class and upload your file as a jar file.
+
+### For Packs
+
+If you're uploading a Pack for Hytale, please make sure you select the "Mods" class and upload your file as a ZIP file
+
+### For Worlds
+
+If you're uploading a World for Hytale, make sure you upload it to the "Worlds" class and upload your file as a ZIP file.
+
+**Once you've uploaded your file, it will be sent for our moderation team to review, and once approved, it will be live for all players on CurseForge!**
+
+## 4. Additional Resources & Guides
+
+You can refer to the following resources for guides on how to create a project page, using the upload API, and creating the best project page:
+
+- How to Pass Moderation Review: https://blog.curseforge.com/how-to-pass-moderation-review-on-curseforge-2/
+- Creating and Submitting a Project: https://support.curseforge.com/en/support/solutions/articles/9000197241-creating-and-submitting-a-project
+- How to Create the Best Project Page: https://blog.curseforge.com/how-to-create-the-best-project-page/
+- Our Mod Approval Process: https://blog.curseforge.com/our-mod-approval-process/
diff --git a/content/docs/cs-CZ/publishing/index.mdx b/content/docs/cs-CZ/publishing/index.mdx
new file mode 100644
index 00000000..fb60fa35
--- /dev/null
+++ b/content/docs/cs-CZ/publishing/index.mdx
@@ -0,0 +1,16 @@
+---
+title: Publishing Your Mod
+description: Learn how to publish your mod to the community.
+---
+
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
+
+We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
+
+- [Publishing on Modtale](./publishing/modtale)
+- [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
+
+<Callout>
+  If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
+</Callout>
diff --git a/content/docs/cs-CZ/publishing/modtale.mdx b/content/docs/cs-CZ/publishing/modtale.mdx
new file mode 100644
index 00000000..3983a5e4
--- /dev/null
+++ b/content/docs/cs-CZ/publishing/modtale.mdx
@@ -0,0 +1,137 @@
+---
+title: Modtale
+description: Complete guide to publishing and managing your Hytale mods on Modtale.
+---
+
+# Publishing Your Mod on Modtale
+
+[Modtale](https://modtale.net) is the Hytale Community Repository for discovering mods, asset packs, worlds, and modpacks.
+
+This guide will walk you through the complete process of publishing your mod.
+
+## Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file of your plugin, or `.zip` of your asset pack
+- A description of your mod's features
+
+We also recommended:
+
+- High-quality screenshots or images of your mod in action
+- A clear logo or icon (recommended size: 512x512px)
+- Any dependencies or requirements documented
+
+## Step-by-Step Publishing Process
+
+### 1. Account Setup
+
+Sign in to [Modtale](https://modtale.net) using your preferred method. If you don't have an account, create one first.
+
+### 2. Start Creating
+
+Click on the **"Create"** button in the navigation bar or go directly to the [upload page](https://modtale.net/upload).
+
+### 3. Choose Content Type
+
+Select the appropriate content type for your submission:
+
+- **Server Plugins** - For Hytale server-side plugins and modifications
+- **Data Assets** - For custom data packs, loot tables, and other data-driven content
+- **Art Assets** - For texture packs, models, and other artistic content
+- **Worlds** - For custom Hytale worlds
+- **Modpacks** - For curated collections of mods and assets
+
+![Content Type Selection](/assets/guides/modtale_type.png)
+
+### 4. Basic Information
+
+Fill in the essential details:
+
+- **Name**: Choose a clear, descriptive name for your mod
+- **Summary**: Write a brief description (1-2 sentences, 250 char max) that explains what your mod does
+
+![Project Title and Description](/assets/guides/modtale_title.png)
+
+### 5. Project Configuration
+
+Now you're on your project's management page. Here you can:
+
+#### Upload Files
+
+Navigate to the **"Files"** tab and upload your `.jar` or `.zip` file:
+
+- Drag and drop your file or use the upload button
+- Add version notes describing changes and new features
+- Mark release type (Release, Beta, Alpha)
+
+![File Upload Interface](/assets/guides/modtale_upload.png)
+
+#### Customize Your Project
+
+- **Logo**: Upload a high-quality logo (512x512 recommended)
+- **Banner**: Upload a banner for your page (1920x640 recommended)
+- **Screenshots**: Add multiple screenshots showing your mod in action
+- **Description**: Write a comprehensive description using Markdown formatting
+- **Links**: Add links to your source code, Discord server, or documentation
+- **Tags**: Add relevant tags to help users find your mod
+- **License**: Indicate what license your mod uses from a selection of common licenses, or use a custom license
+
+## Best Practices
+
+### Documentation
+
+<Callout type="info">
+  Always include comprehensive documentation in your mod description. Users should understand what your mod does, how to use it, and any special requirements.
+</Callout>
+
+### Version Notes
+
+When uploading new versions:
+
+- You must adhere to SemVer
+- Clearly document all changes and new features
+- Include bug fixes and known issues
+- Mention any breaking changes or migration steps
+- List new dependencies or requirement changes
+
+### Visual Appeal
+
+- Use high-quality screenshots that showcase your mod's features in the gallery
+- Create an eye-catching logo that represents your mod
+- Consider adding a banner image for your project page
+
+### Community Engagement
+
+- Respond to comments and feedback promptly
+- Consider creating a Discord server for community support
+- Regularly update your mod based on user feedback
+
+## After Publishing
+
+### Automated updates
+
+- You can configure your project to automatically upload new versions using Github Actions, Gradle, Maven, or Go. See examples [here](https://github.com/Modtale/modtale-example)
+
+### Monitoring Your Project
+
+- Check the analytics to see download statistics
+- Monitor comments and reviews
+- Keep track of bug reports and feature requests
+
+### Marketing Your Mod
+
+- Share your mod on relevant Hytale communities
+- Create showcase videos or tutorials
+- Engage with other modders and creators
+
+<Callout type="warning">
+  Remember to keep your mod updated for new Hytale versions and maintain compatibility with Hytale's modding framework to maximize your audience reach.
+</Callout>
+
+## Getting Help
+
+If you encounter any issues during the publishing process:
+
+- Join their Discord community for support
+- Contact the Modtale team directly through their support channels
diff --git a/content/docs/cs-CZ/quick-start.mdx b/content/docs/cs-CZ/quick-start.mdx
new file mode 100644
index 00000000..18ab3e2d
--- /dev/null
+++ b/content/docs/cs-CZ/quick-start.mdx
@@ -0,0 +1,11 @@
+---
+title: Quick Start
+description: Setting up a standard Hytale project.
+---
+
+Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+
+* [Java Basics](./guides/java-basics/00-introduction)
+* [Setting up your dev environment](./guides/plugin/setting-up-env)
+* [Entity Component System (ECS)](./guides/ecs)
+* [Publishing your mod](./guides/publishing)
diff --git a/content/docs/cs-CZ/server/entities.mdx b/content/docs/cs-CZ/server/entities.mdx
new file mode 100644
index 00000000..872f3fa4
--- /dev/null
+++ b/content/docs/cs-CZ/server/entities.mdx
@@ -0,0 +1,441 @@
+---
+title: Entities
+description: List of all Entities in Hytale
+icon: List
+full: true
+---
+
+This page contains a list of all Entities available to be used as a key in the AssetMap.
+
+- Antelope
+- Archaeopteryx
+- Armadillo
+- Arrow_Crossbow_Signature
+- Arrow_Crude
+- Arrow_Fire
+- Arrow_Frost
+- Arrow_Iron
+- Arrow_Ricochet
+- Arrow_Ricochet_Signature
+- Arrow_Shortbow_Signature
+- Arrow_Vamp
+- Arrow_Vamp_Signature
+- Axe_Bone
+- Axe_Stone_Trork
+- Bat
+- Bat_Ice
+- Bear_Grizzly
+- Bear_Polar
+- Bison
+- Bison_Calf
+- Bluebird
+- Bluegill
+- Boar
+- Boar_Piglet
+- Boat
+- Bomb
+- Bomb_Fire_Goblin
+- Bomb_Fire_Goblin_Dud
+- Bomb_Large_Fire_Goblin
+- Bomb_Popberry
+- Bomb_Potion_Poison
+- Boy_Trail
+- Bramblekin
+- Bramblekin_Shaman
+- Bullet_Blunderbuss
+- Bunny
+- Cactee
+- Cactee_Spike
+- Calf
+- Camel
+- Camel_Calf
+- Cat
+- Catfish
+- Chick
+- Chick_Desert
+- Chicken
+- Chicken_Desert
+- Chicken_Undead
+- Clownfish
+- Corgi
+- Cow
+- Cow_Undead
+- Crab
+- Crawler_Void
+- Crocodile
+- Crossbow_Turret
+- Crossbow_Turret_Item_Projectile
+- Crow
+- Dagger_Adamantite
+- Dagger_Bone
+- Dagger_Bronze
+- Dagger_Bronze_Ancient
+- Dagger_Cobalt
+- Dagger_Copper
+- Dagger_Crude
+- Dagger_Doomed
+- Dagger_Fang_Doomed
+- Dagger_Iron
+- Dagger_Mithril
+- Dagger_Onyxium
+- Dagger_Stone_Trork
+- Dagger_Thorium
+- Debug
+- Deer_Doe
+- Deployable_Fire_Trap
+- Deployable_Fire_Trap_Preview
+- Dog
+- Dragon_Fire
+- Dragon_Frost
+- Dragon_Void
+- Duck
+- Eel_Moray
+- Egg
+- Emberwulf
+- Eye_Void
+- Eye_Void_Blast
+- Fen_Stalker
+- Feran
+- Feran_Burrower
+- Feran_Civilian
+- Feran_Cub
+- Feran_Longtooth
+- Feran_Sharptooth
+- Feran_Windwalker
+- Feran_Windwalker_Wind_Burst
+- Feran_Windwalker_Wind_Vortex
+- Finch_Green
+- Fireball
+- Flamingo
+- Fox
+- Frog_Blue
+- Frog_Green
+- Frog_Orange
+- Frostgill
+- Gecko
+- Ghoul
+- Goat
+- Goat_Kid
+- Goblin
+- Goblin_Boss
+- Goblin_Duke
+- Goblin_Duke_Large
+- Goblin_Hermit
+- Goblin_Lobber
+- Goblin_Miner
+- Goblin_Ogre
+- Goblin_Scrapper
+- Goblin_Thief
+- Golem_Crystal_Earth
+- Golem_Crystal_Flame
+- Golem_Crystal_Frost
+- Golem_Crystal_Sand
+- Golem_Crystal_Thunder
+- Golem_Firesteel
+- Golem_Guardian_Void
+- Grooble
+- Hatworm
+- Hawk
+- Healing_Totem
+- Healing_Totem_Projectile
+- Hedera
+- Horse
+- Horse_Foal
+- Horse_Skeleton
+- Horse_Skeleton_Armored
+- Hound_Bleached
+- Hyena
+- Ice_Ball
+- Ice_Bolt
+- Ingredient_Poop
+- Jellyfish_Blue
+- Jellyfish_Cyan
+- Jellyfish_Green
+- Jellyfish_Man_Of_War
+- Jellyfish_Red
+- Jellyfish_Yellow
+- Klops
+- Klops_Gentleman
+- Klops_Merchant
+- Klops_Miner
+- Kunai
+- Kweebec_Rootling
+- Kweebec_Sapling
+- Kweebec_Sapling_Brown
+- Kweebec_Sapling_Christmas_Blue
+- Kweebec_Sapling_Christmas_Green
+- Kweebec_Sapling_Christmas_Pink
+- Kweebec_Sapling_Green
+- Kweebec_Sapling_HardHat
+- Kweebec_Sapling_Orange
+- Kweebec_Sapling_Pink
+- Kweebec_Sapling_Razorleaf
+- Kweebec_Sapling_Red
+- Kweebec_Sapling_Treesinger
+- Kweebec_Sapling_Yellow
+- Kweebec_Seedling
+- Kweebec_Sproutling
+- Kweebec_Sproutling_Blue
+- Kweebec_Sproutling_Lime
+- Lamb
+- Larva_Silk
+- Larva_Void
+- Leopard_Snow
+- Lizard_Sand
+- Lobster
+- Mannequin
+- Meerkat
+- Minecart
+- Minnow
+- Model_Bee_Swarm
+- Model_Deer_Stag
+- Molerat
+- Moose_Bull
+- Moose_Cow
+- Mosshorn
+- Mosshorn_Plain
+- Mouflon
+- Mouflon_Lamb
+- Mouse
+- Mushee
+- NPC_Elf
+- NPC_Path_Marker
+- NPC_Santa
+- NPC_Sound_Shoe
+- NPC_Spawn_Marker
+- Necromancer_Void
+- Objective_Location_Marker
+- Outlander
+- Outlander_Berserker
+- Outlander_Brute
+- Outlander_Cultist
+- Outlander_Hunter
+- Outlander_Marauder
+- Outlander_Peon
+- Outlander_Priest
+- Outlander_Sorcerer
+- Outlander_Stalker
+- Owl_Brown
+- Owl_Snow
+- Parrot
+- Penguin
+- Pig
+- Pig_Undead
+- Pig_Wild
+- Pigeon
+- Piglet
+- Piglet_Wild
+- Pike
+- Piranha
+- Piranha_Black
+- Player
+- PlayerTestModel_G
+- PlayerTestModel_V
+- Projectile
+- Pterodactyl
+- Pufferfish
+- Rabbit
+- Ram
+- Ram_Lamb
+- Raptor_Cave
+- Rat
+- Raven
+- Reindeer_Christmas
+- Rex_Cave
+- Rubble_Aqua
+- Rubble_Basalt
+- Rubble_Calcite
+- Rubble_Default
+- Rubble_Ice
+- Rubble_Marble
+- Rubble_Quartzite
+- Rubble_Sandstone
+- Rubble_Sandstone_Red
+- Rubble_Sandstone_White
+- Rubble_Shale
+- Rubble_Slate
+- Rubble_Stone
+- Rubble_Stone_Mossy
+- Rubble_Volcanic
+- Salmon
+- Saurian
+- Saurian_Hunter
+- Saurian_Rogue
+- Saurian_Warrior
+- Scarak_Broodmother
+- Scarak_Broodmother_Young
+- Scarak_Defender
+- Scarak_Fighter
+- Scarak_Fighter_Royal_Guard
+- Scarak_Louse
+- Scarak_Seeker
+- Scarak_Seeker_Spitball
+- Scorpion
+- Shadow_Knight
+- Shark_Hammerhead
+- Sheep
+- Shellfish_Lava
+- Showcase_Cobalt_Gear
+- Showcase_Copper_Gear
+- Showcase_Iron_Gear
+- Showcase_Iron_TargetDummy_1
+- Showcase_Mannequin_Heal
+- Showcase_Mannequin_Inv_Portal
+- Showcase_Mannequin_Inv_Sphere
+- Showcase_Mannequin_Lightning
+- Showcase_Mannequin_Sitting
+- Showcase_Onyxium_Gear
+- Showcase_Prisma_Gear
+- Showcase_Skeleton_Assasin
+- Showcase_Skeleton_Dead
+- Showcase_Skeleton_Guard
+- Showcase_Skeleton_Tank
+- Showcase_Wooden_Gear
+- Skeleton
+- Skeleton_Archer
+- Skeleton_Archmage
+- Skeleton_Burnt_Alchemist
+- Skeleton_Burnt_Archer
+- Skeleton_Burnt_Gunner
+- Skeleton_Burnt_Knight
+- Skeleton_Burnt_Lancer
+- Skeleton_Burnt_Praetorian
+- Skeleton_Burnt_Soldier
+- Skeleton_Burnt_Wizard
+- Skeleton_Fighter
+- Skeleton_Frost_Archer
+- Skeleton_Frost_Archmage
+- Skeleton_Frost_Fighter
+- Skeleton_Frost_Knight
+- Skeleton_Frost_Mage
+- Skeleton_Frost_Ranger
+- Skeleton_Frost_Scout
+- Skeleton_Frost_Soldier
+- Skeleton_Incandescent_Fighter
+- Skeleton_Incandescent_Footman
+- Skeleton_Incandescent_Head
+- Skeleton_Incandescent_Mage
+- Skeleton_Knight
+- Skeleton_Mage
+- Skeleton_Mage_Corruption_Orb
+- Skeleton_Pirate_Captain
+- Skeleton_Pirate_Gunner
+- Skeleton_Pirate_Striker
+- Skeleton_Ranger
+- Skeleton_Sand_Archer
+- Skeleton_Sand_Archmage
+- Skeleton_Sand_Assassin
+- Skeleton_Sand_Guard
+- Skeleton_Sand_Mage
+- Skeleton_Sand_Ranger
+- Skeleton_Sand_Scout
+- Skeleton_Sand_Soldier
+- Skeleton_Scout
+- Skeleton_Soldier
+- Skrill
+- Skrill_Chick
+- Slothian
+- Slothian_Elder
+- Slothian_Kid
+- Slothian_Monk
+- Slothian_Scout
+- Slothian_Villager
+- Slothian_Warrior
+- Slowness_Totem
+- Slowness_Totem_Projectile
+- Slug_Magma
+- Snail_Frost
+- Snail_Magma
+- Snake_Cobra
+- Snake_Marsh
+- Snake_Rattle
+- Snapdragon
+- Snapjaw
+- Spark_Living
+- Sparrow
+- Spawn_Void
+- Spear_Adamantite
+- Spear_Adamantite_Saurian
+- Spear_Bone
+- Spear_Bronze
+- Spear_Cobalt
+- Spear_Copper
+- Spear_Crude
+- Spear_Double_Incandescent
+- Spear_Iron
+- Spear_Leaf
+- Spear_Mithril
+- Spear_Onyxium
+- Spear_Scrap
+- Spear_Stone_Trork
+- Spear_Thorium
+- Spear_Tribal
+- Spectre_Void
+- Spider
+- Spider_Cave
+- Spirit_Ember
+- Spirit_Frost
+- Spirit_Root
+- Spirit_Thunder
+- Squirrel
+- Swarm_Bees
+- Sword_Charged_Test
+- Tang_Blue
+- Tang_Chevron
+- Tang_Lemon_Peel
+- Tang_Sailfin
+- Tank
+- Temple_Mithril_Guard
+- Test_Platform
+- Tetrabird
+- Tiger_Sabertooth
+- Toad_Rhino
+- Toad_Rhino_Magma
+- Tornado
+- Tortoise
+- Trash
+- Trillodon
+- Trilobite
+- Trilobite_Black
+- Trork
+- Trork_Brawler
+- Trork_Chieftain
+- Trork_Christmas
+- Trork_Doctor_Witch
+- Trork_Guard
+- Trork_Hunter
+- Trork_Mauler
+- Trork_Sentry
+- Trork_Shaman
+- Trork_Warrior
+- Trout_Rainbow
+- Tuluk
+- Tuluk_Fisherman
+- Turkey
+- Turkey_Chick
+- Vulture
+- Warp
+- Warrior_Quest
+- Warthog
+- Warthog_Piglet
+- Werewolf
+- Whale_Humpback
+- Wolf_Black
+- Wolf_Outlander_Priest
+- Wolf_Outlander_Sorcerer
+- Wolf_Trork_Hunter
+- Wolf_Trork_Shaman
+- Wolf_White
+- Woodpecker
+- Wraith
+- Wraith_Lantern
+- Wurmling_Frost
+- Yeti
+- Zombie
+- Zombie_Aberrant
+- Zombie_Aberrant_Big
+- Zombie_Aberrant_Small
+- Zombie_Burnt
+- Zombie_Frost
+- Zombie_Sand
+- Zombie_Werewolf
diff --git a/content/docs/cs-CZ/server/events.mdx b/content/docs/cs-CZ/server/events.mdx
new file mode 100644
index 00000000..ca7ed28f
--- /dev/null
+++ b/content/docs/cs-CZ/server/events.mdx
@@ -0,0 +1,104 @@
+---
+title: Events
+description: List of all events in Hytale
+icon: List
+full: true
+---
+
+## IEvent
+
+- AddPlayerToWorldEvent
+- AllNPCsLoadedEvent
+- AllWorldsLoadedEvent
+- AssetMonitorEvent
+  - AssetStoreMonitorEvent
+  - CommonAssetMonitorEvent
+- AssetPackRegisterEvent
+- AssetPackUnregisterEvent
+- AssetStoreEvent
+  - RegisterAssetStoreEvent
+  - RemoveAssetStoreEvent
+- AssetsEvent
+  - GenerateAssetsEvent
+  - LoadedAssetsEvent
+  - RemovedAssetsEvent
+- BootEvent
+- ChunkEvent
+  - ChunkPreLoadProcessEvent
+- DrainPlayerFromWorldEvent
+- EditorClientEvent
+  - AssetEditorActivateButtonEvent
+  - AssetEditorAssetCreatedEvent
+  - AssetEditorClientDisconnectEvent
+  - AssetEditorSelectAssetEvent
+  - AssetEditorUpdateWeatherPreviewLockEvent
+- EntityEvent
+  - EntityRemoveEvent
+  - LivingEntityInventoryChangeEvent
+- GenerateDefaultLanguageEvent
+- GenerateSchemaEvent
+- GenerateServerStateEvent
+- ItemContainerChangeEvent
+- ~~LivingEntityUseBlockEvent~~ DEPRECATED
+- LoadAssetEvent
+- LoadedNPCEvent
+- MessagesUpdated
+- PlayerConnectEvent
+- PlayerEvent
+  - ~~PlayerCraftEvent~~ DEPRECATED
+  - ~~PlayerInteractEvent~~ DEPRECATED
+  - PlayerMouseButtonEvent
+  - PlayerMouseMotionEvent
+  - PlayerReadyEvent
+  - RemovePlayerFromWorldEvent
+- PlayerRefEvent
+  - PlayerDisconnectEvent
+- PlayerSetupConnectEvent
+- PlayerSetupDisconnectEvent
+- PluginEvent
+  - PluginSetupEvent
+- ~~PrepareUniverseEvent~~ DEPRECATED
+- ShutdownEvent
+- SingleplayerRequestAccessEvent
+- TreasureChestOpeningEvent
+- WindowCloseEvent
+- WorldEvent
+  - AddWorldEvent
+  - RemoveWorldEvent
+  - StartWorldEvent
+- WorldPathChangedEvent
+
+## IAsyncEvent
+
+- AssetEditorFetchAutoCompleteDataEvent
+- AssetEditorRequestDataSetEvent
+- PlayerChatEvent
+- SendCommonAssetsEvent
+
+## EcsEvent
+
+- CancellableEcsEvent
+  - BreakBlockEvent
+  - ChangeGameModeEvent
+  - ChunkSaveEvent
+  - ChunkUnloadEvent
+  - CraftRecipeEvent
+    - Post
+    - Pre
+  - Damage
+  - DamageBlockEvent
+  - DropItemEvent
+    - Drop
+    - PlayerRequest
+  - InteractivelyPickupItemEvent
+  - PlaceBlockEvent
+  - PrefabPasteEvent
+  - SwitchActiveSlotEvent
+- DiscoverInstanceEvent
+  - Display
+- DiscoverZoneEvent
+  - Display
+- MoonPhaseChangeEvent
+- UseBlockEvent
+  - Post
+  - Pre
diff --git a/content/docs/cs-CZ/server/sounds.mdx b/content/docs/cs-CZ/server/sounds.mdx
new file mode 100644
index 00000000..5b54a035
--- /dev/null
+++ b/content/docs/cs-CZ/server/sounds.mdx
@@ -0,0 +1,1162 @@
+---
+title: Sounds
+description: List of all Sounds in Hytale
+icon: List
+full: true
+---
+
+This page contains a list of all Sounds available to be used as a key in the AssetMap.
+
+- SFX_Alchemy_Bench_Close
+- SFX_Alchemy_Bench_Craft
+- SFX_Alchemy_Bench_Open
+- SFX_Antelope_Alerted
+- SFX_Antelope_Death
+- SFX_Antelope_Hurt
+- SFX_Antelope_Run
+- SFX_Antelope_Walk
+- SFX_Arcane_Workbench_Close_Local
+- SFX_Arcane_Workbench_Craft
+- SFX_Arcane_Workbench_Open_Local
+- SFX_Armour_Bench_Close
+- SFX_Armour_Bench_Craft
+- SFX_Armour_Bench_Open
+- SFX_Arrow_Fire_Hit
+- SFX_Arrow_Fire_Miss
+- SFX_Arrow_Frost_Hit
+- SFX_Arrow_Frost_Miss
+- SFX_Arrow_FullCharge_Hit
+- SFX_Arrow_FullCharge_Miss
+- SFX_Arrow_HalfCharge_Hit
+- SFX_Arrow_HalfCharge_Miss
+- SFX_Arrow_NoCharge_Hit
+- SFX_Arrow_NoCharge_Miss
+- SFX_Arrow_Whistle
+- SFX_Attn_Loud
+- SFX_Attn_Moderate
+- SFX_Attn_Quiet
+- SFX_Attn_VeryLoud
+- SFX_Attn_VeryQuiet
+- SFX_Avatar_Powers_Disable
+- SFX_Avatar_Powers_Disable_Local
+- SFX_Avatar_Powers_Enable
+- SFX_Avatar_Powers_Enable_Local
+- SFX_Axe_Crude_Impact
+- SFX_Axe_Crude_Swing
+- SFX_Axe_Iron_Impact
+- SFX_Axe_Iron_Swing
+- SFX_Axe_Special_Impact
+- SFX_Axe_Special_Swing
+- SFX_Axe_Stone_Trork_Hit
+- SFX_Axe_Stone_Trork_Miss
+- SFX_Bat_Alerted
+- SFX_Bat_Death
+- SFX_Bat_Hurt
+- SFX_Battleaxe_T1_Block_Impact
+- SFX_Battleaxe_T1_Impact
+- SFX_Battleaxe_T1_Launch
+- SFX_Battleaxe_T1_Launch_Local
+- SFX_Battleaxe_T1_Raise
+- SFX_Battleaxe_T1_Raise_Local
+- SFX_Battleaxe_T1_Shove
+- SFX_Battleaxe_T1_Shove_Local
+- SFX_Battleaxe_T1_Swing
+- SFX_Battleaxe_T1_Swing_Charged
+- SFX_Battleaxe_T1_Swing_Charged_Local
+- SFX_Battleaxe_T1_Swing_Down_Local
+- SFX_Battleaxe_T1_Swing_LR_Local
+- SFX_Battleaxe_T1_Swing_RL_Local
+- SFX_Battleaxe_T2_Impact
+- SFX_Battleaxe_T2_Raise
+- SFX_Battleaxe_T2_Raise_Local
+- SFX_Battleaxe_T2_Signature_End
+- SFX_Battleaxe_T2_Signature_End_Local
+- SFX_Battleaxe_T2_Signature_Swing
+- SFX_Battleaxe_T2_Signature_Swing_Local
+- SFX_Battleaxe_T2_Swing
+- SFX_Battleaxe_T2_Swing_Charged
+- SFX_Battleaxe_T2_Swing_Charged_Local
+- SFX_Battleaxe_T2_Swing_Down_Local
+- SFX_Battleaxe_T2_Swing_LR_Local
+- SFX_Battleaxe_T2_Swing_RL_Local
+- SFX_Bear_Grizzly_Alerted
+- SFX_Bear_Grizzly_Attack
+- SFX_Bear_Grizzly_Death
+- SFX_Bear_Grizzly_Hurt
+- SFX_Bear_Grizzly_Run
+- SFX_Bear_Grizzly_Sleep
+- SFX_Bear_Walk
+- SFX_Bench_Placeholder
+- SFX_Bison_Alerted
+- SFX_Bison_Death
+- SFX_Bison_Hurt
+- SFX_Bison_Idle
+- SFX_Bison_Run
+- SFX_Bison_Walk
+- SFX_Blunderbuss_Bullet_WhizBy
+- SFX_Blunderbuss_Fire
+- SFX_Blunderbuss_Fire_Local
+- SFX_Blunderbuss_Hit
+- SFX_Blunderbuss_Load
+- SFX_Blunderbuss_Load_Local
+- SFX_Blunderbuss_Miss
+- SFX_Blunderbuss_No_Ammo
+- SFX_Boar_Alerted
+- SFX_Boar_Death
+- SFX_Boar_Hurt
+- SFX_Boar_Run
+- SFX_Boar_Sleep
+- SFX_Boar_Walk
+- SFX_Bomb_Fire_Goblin_Bounce
+- SFX_Bomb_Fire_Goblin_Death
+- SFX_Bomb_Fire_Goblin_Hit
+- SFX_Bomb_Fire_Goblin_Miss
+- SFX_Bomb_Fuse
+- SFX_Bone_Break
+- SFX_Bone_Build
+- SFX_Bone_Hit
+- SFX_Bone_Land
+- SFX_Bone_Walk
+- SFX_Bow_No_Ammo
+- SFX_Bow_T1_Block_Impact
+- SFX_Bow_T1_Draw
+- SFX_Bow_T1_Draw_Local
+- SFX_Bow_T1_Raise
+- SFX_Bow_T1_Raise_Local
+- SFX_Bow_T1_Shoot
+- SFX_Bow_T1_Shoot_Local
+- SFX_Bow_T1_Swing
+- SFX_Bow_T1_Swing_Local
+- SFX_Bow_T2_Draw
+- SFX_Bow_T2_Draw_Local
+- SFX_Bow_T2_Shoot
+- SFX_Bow_T2_Shoot_Local
+- SFX_Bow_T2_Signature_Loop
+- SFX_Bow_T2_Signature_Loop_Local
+- SFX_Bow_T2_Signature_Nock
+- SFX_Bow_T2_Signature_Nock_Local
+- SFX_Bow_T2_Signature_Shoot
+- SFX_Bow_T2_Signature_Shoot_Local
+- SFX_Bramble_MoveIn
+- SFX_Branch_Break
+- SFX_Branch_Build
+- SFX_Branch_Hit
+- SFX_Branch_Land
+- SFX_Branch_Walk
+- SFX_Brazier_Break
+- SFX_Brazier_Build
+- SFX_Bunny_Alerted
+- SFX_Bunny_Death
+- SFX_Bunny_Hurt
+- SFX_Bush_Break
+- SFX_Bush_Hit
+- SFX_Bush_MoveIn
+- SFX_Cactus_Break
+- SFX_Cactus_Hit
+- SFX_Cactus_Large_Hit
+- SFX_Cactus_Small_Break
+- SFX_Cactus_Small_Hit
+- SFX_Calf_Hurt
+- SFX_Calf_Run
+- SFX_Calf_Walk
+- SFX_Camel_Alerted
+- SFX_Camel_Death
+- SFX_Camel_Hurt
+- SFX_Camel_Laydown
+- SFX_Camel_Run
+- SFX_Camel_Sleep
+- SFX_Camel_Wake
+- SFX_Camel_Walk
+- SFX_Campfire_Break
+- SFX_Campfire_Build
+- SFX_Campfire_Close_Local
+- SFX_Campfire_Default_Loop
+- SFX_Campfire_Open_Local
+- SFX_Campfire_Processing
+- SFX_Campfire_Processing_End
+- SFX_Campfire_Processing_Failed
+- SFX_Candle_Default_Loop
+- SFX_Candle_Off
+- SFX_Capture_Crate_Capture_Fail_Local
+- SFX_Capture_Crate_Capture_Succeed
+- SFX_Capture_Crate_Capture_Succeed_Local
+- SFX_Capture_Crate_Spawn_Fail_Local
+- SFX_Capture_Crate_Spawn_Succeed
+- SFX_Cauldron_Bubbling
+- SFX_Cauldron_Bubbling_Small
+- SFX_Chest_Legendary_Close_Player
+- SFX_Chest_Legendary_FirstOpen_Player
+- SFX_Chest_Legendary_Loop
+- SFX_Chest_Legendary_Open
+- SFX_Chest_Wooden_Close
+- SFX_Chest_Wooden_Open
+- SFX_Chest_Wooden_Open_Player
+- SFX_Chick_Alerted
+- SFX_Chick_Death
+- SFX_Chick_Hurt
+- SFX_Chicken_Alerted
+- SFX_Chicken_Death
+- SFX_Chicken_Flee
+- SFX_Chicken_Hurt
+- SFX_Chicken_Run
+- SFX_Chicken_Walk
+- SFX_Clay_Pot_Large_Break
+- SFX_Clay_Pot_Large_Build
+- SFX_Clay_Pot_Large_Hit
+- SFX_Clay_Pot_Large_Walk
+- SFX_Clay_Pot_Small_Break
+- SFX_Clay_Pot_Small_Build
+- SFX_Clay_Pot_Small_Hit
+- SFX_Clay_Pot_Small_Walk
+- SFX_Cloth_Break
+- SFX_Cloth_Build
+- SFX_Cloth_Hit
+- SFX_Cloth_Land
+- SFX_Cloth_Walk
+- SFX_Club_Meat_Impact
+- SFX_Club_Meat_Swing
+- SFX_Club_Special_Impact
+- SFX_Club_Special_Swing
+- SFX_Club_Steel_Impact
+- SFX_Club_Steel_Swing
+- SFX_Club_Wood_Impact
+- SFX_Club_Wood_Swing
+- SFX_Cocoon_Active
+- SFX_Cocoon_Break
+- SFX_Cocoon_Build
+- SFX_Cocoon_Hit
+- SFX_Cocoon_Walk
+- SFX_Coins_Land
+- SFX_Coins_Walk
+- SFX_Consume_Bread
+- SFX_Consume_Bread_Local
+- SFX_Cow_Alerted
+- SFX_Cow_Death
+- SFX_Cow_Hurt
+- SFX_Cow_Idle
+- SFX_Cow_Run
+- SFX_Cow_Sleep
+- SFX_Cow_Walk
+- SFX_Crawler_Void_Alerted
+- SFX_Crawler_Void_Alerted_02
+- SFX_Crawler_Void_Death
+- SFX_Crawler_Void_Despawn
+- SFX_Crawler_Void_Hurt
+- SFX_Crawler_Void_Run
+- SFX_Crawler_Void_Sleep
+- SFX_Crawler_Void_Spawn
+- SFX_Crawler_Void_Spawn_02
+- SFX_Crawler_Void_Walk
+- SFX_Creative_Play_Add_Mask
+- SFX_Creative_Play_Brush_Erase
+- SFX_Creative_Play_Brush_Mode
+- SFX_Creative_Play_Brush_Paint_Base
+- SFX_Creative_Play_Brush_Paint_Idle_Layer
+- SFX_Creative_Play_Brush_Paint_Move_Layer
+- SFX_Creative_Play_Brush_Shape
+- SFX_Creative_Play_Brush_Stamp
+- SFX_Creative_Play_Error
+- SFX_Creative_Play_Eyedropper_Select
+- SFX_Creative_Play_Paste
+- SFX_Creative_Play_Selection_Drag
+- SFX_Creative_Play_Selection_Place
+- SFX_Creative_Play_Selection_Scale
+- SFX_Creative_Play_Selection_Widget
+- SFX_Creative_Play_Set_Mask
+- SFX_Crocodile_Alerted
+- SFX_Crocodile_Death
+- SFX_Crocodile_Hurt
+- SFX_Crops_Grow
+- SFX_Crops_Grow_Stage_Complete
+- SFX_Crow_Death
+- SFX_Crow_Hurt
+- SFX_Crystal_Break
+- SFX_Crystal_Build
+- SFX_Crystal_Hit
+- SFX_Crystal_Walk
+- SFX_Daggers_T1_Guard
+- SFX_Daggers_T1_Guard_Local
+- SFX_Daggers_T1_Pounce
+- SFX_Daggers_T1_Pounce_Local
+- SFX_Daggers_T1_Slash_Impact
+- SFX_Daggers_T1_Stab_Double_Impact
+- SFX_Daggers_T1_Stab_Impact
+- SFX_Daggers_T1_Stab_Left_Local
+- SFX_Daggers_T1_Stab_Retreat
+- SFX_Daggers_T1_Stab_Retreat_Local
+- SFX_Daggers_T1_Stab_Right_Local
+- SFX_Daggers_T1_Swing
+- SFX_Daggers_T1_Swing_Double
+- SFX_Daggers_T1_Swing_Double_Local
+- SFX_Daggers_T1_Swing_LR_Local
+- SFX_Daggers_T1_Swing_RL_Local
+- SFX_Daggers_T2_Guard
+- SFX_Daggers_T2_Guard_Local
+- SFX_Daggers_T2_Signature_P1
+- SFX_Daggers_T2_Signature_P1_Local
+- SFX_Daggers_T2_Signature_P2
+- SFX_Daggers_T2_Signature_P2_Local
+- SFX_Daggers_T2_Signature_P3
+- SFX_Daggers_T2_Signature_P3_Local
+- SFX_Daggers_T2_Slash_Impact
+- SFX_Daggers_T2_Stab_Double_Impact
+- SFX_Daggers_T2_Stab_Impact
+- SFX_Daggers_T2_Stab_Left_Local
+- SFX_Daggers_T2_Stab_Retreat
+- SFX_Daggers_T2_Stab_Retreat_Local
+- SFX_Daggers_T2_Stab_Right_Local
+- SFX_Daggers_T2_Swing
+- SFX_Daggers_T2_Swing_Double
+- SFX_Daggers_T2_Swing_Double_Local
+- SFX_Daggers_T2_Swing_LR_Local
+- SFX_Daggers_T2_Swing_RL_Local
+- SFX_Deer_Doe_Alerted
+- SFX_Deer_Doe_Death
+- SFX_Deer_Doe_Hurt
+- SFX_Deer_Doe_Run
+- SFX_Deer_Doe_Sleep
+- SFX_Deer_Stag_Alerted
+- SFX_Deer_Stag_Death
+- SFX_Deer_Stag_Hurt
+- SFX_Deer_Stag_Roar
+- SFX_Deer_Stag_Run
+- SFX_Deer_Stag_Sleep
+- SFX_Deer_Walk
+- SFX_Default_Break
+- SFX_Default_Build
+- SFX_Default_Clone
+- SFX_Default_Harvest
+- SFX_Default_Walk
+- SFX_Deployable_Totem_Heal_Despawn
+- SFX_Deployable_Totem_Heal_Effect_Local
+- SFX_Deployable_Totem_Heal_Spawn
+- SFX_Deployable_Totem_Slowing_Despawn
+- SFX_Deployable_Totem_Slowing_Effect_Local
+- SFX_Deployable_Totem_Slowing_Spawn
+- SFX_Dirt_Break
+- SFX_Dirt_Build
+- SFX_Dirt_Clone
+- SFX_Dirt_Hit
+- SFX_Dirt_Land
+- SFX_Dirt_Walk
+- SFX_Discovery_Z1_Medium
+- SFX_Discovery_Z1_Short
+- SFX_Discovery_Z2_Medium
+- SFX_Discovery_Z2_Short
+- SFX_Discovery_Z3_Medium
+- SFX_Discovery_Z3_Short
+- SFX_Discovery_Z4_Medium
+- SFX_Discovery_Z4_Short
+- SFX_Divine_Respawn
+- SFX_Door_Ancient_Close
+- SFX_Door_Ancient_Open
+- SFX_Door_Crude_Close
+- SFX_Door_Crude_Open
+- SFX_Door_Desert_Close
+- SFX_Door_Desert_Open
+- SFX_Door_Jungle_Close
+- SFX_Door_Jungle_Open
+- SFX_Door_Lumberjack_Close
+- SFX_Door_Lumberjack_Open
+- SFX_Door_Temple_Dark_Close
+- SFX_Door_Temple_Dark_Open
+- SFX_Door_Temple_Light_Close
+- SFX_Door_Temple_Light_Open
+- SFX_Door_Wooden_Close
+- SFX_Door_Wooden_Open
+- SFX_Drag_Armor_Cloth
+- SFX_Drag_Armor_Heavy
+- SFX_Drag_Armor_Leather
+- SFX_Drag_Blocks_Gravel
+- SFX_Drag_Blocks_Soft
+- SFX_Drag_Blocks_Splatty
+- SFX_Drag_Blocks_Stone
+- SFX_Drag_Blocks_Wood
+- SFX_Drag_Item_Default
+- SFX_Drag_Items_Bones
+- SFX_Drag_Items_Chest
+- SFX_Drag_Items_Clay
+- SFX_Drag_Items_Cloth
+- SFX_Drag_Items_Foliage
+- SFX_Drag_Items_Gadget
+- SFX_Drag_Items_Gems
+- SFX_Drag_Items_Ingots
+- SFX_Drag_Items_Leather
+- SFX_Drag_Items_Metal
+- SFX_Drag_Items_Paper
+- SFX_Drag_Items_Potion
+- SFX_Drag_Items_Seeds
+- SFX_Drag_Items_Shells
+- SFX_Drag_Items_Splatty
+- SFX_Drag_Weapon_Blade_Small
+- SFX_Drag_Weapon_Blunt_Large
+- SFX_Drag_Weapons_Arrows
+- SFX_Drag_Weapons_Blade_Large
+- SFX_Drag_Weapons_Blunt_Small
+- SFX_Drag_Weapons_Books
+- SFX_Drag_Weapons_Shield_Metal
+- SFX_Drag_Weapons_Shield_Wood
+- SFX_Drag_Weapons_Stone_Large
+- SFX_Drag_Weapons_Stone_Small
+- SFX_Drag_Weapons_Wand
+- SFX_Drag_Weapons_Wood
+- SFX_Dragon_Sleep
+- SFX_Drop_Armor_Cloth
+- SFX_Drop_Armor_Heavy
+- SFX_Drop_Armor_Leather
+- SFX_Drop_Blocks_Gravel
+- SFX_Drop_Blocks_Soft
+- SFX_Drop_Blocks_Splatty
+- SFX_Drop_Blocks_Stone
+- SFX_Drop_Blocks_Wood
+- SFX_Drop_Item_Default
+- SFX_Drop_Items_Bones
+- SFX_Drop_Items_Chest
+- SFX_Drop_Items_Clay
+- SFX_Drop_Items_Cloth
+- SFX_Drop_Items_Foliage
+- SFX_Drop_Items_Gadget
+- SFX_Drop_Items_Gems
+- SFX_Drop_Items_Ingots
+- SFX_Drop_Items_Leather
+- SFX_Drop_Items_Metal
+- SFX_Drop_Items_Paper
+- SFX_Drop_Items_Potion
+- SFX_Drop_Items_Seeds
+- SFX_Drop_Items_Shells
+- SFX_Drop_Items_Splatty
+- SFX_Drop_Weapon_Blade_Small
+- SFX_Drop_Weapon_Blunt_Large
+- SFX_Drop_Weapons_Arrows
+- SFX_Drop_Weapons_Blade_Large
+- SFX_Drop_Weapons_Blunt_Small
+- SFX_Drop_Weapons_Books
+- SFX_Drop_Weapons_Shield_Metal
+- SFX_Drop_Weapons_Shield_Wood
+- SFX_Drop_Weapons_Stone_Large
+- SFX_Drop_Weapons_Stone_Small
+- SFX_Drop_Weapons_Wand
+- SFX_Drop_Weapons_Wood
+- SFX_Duck_Alerted
+- SFX_Duck_Death
+- SFX_Duck_Hurt
+- SFX_Duck_Run
+- SFX_Effect_Burn_Local
+- SFX_Effect_Burn_World
+- SFX_Effect_Poison_Local
+- SFX_Effect_Poison_World
+- SFX_Egg_Hit
+- SFX_Egg_Miss
+- SFX_Eggsac_Active
+- SFX_Emberwulf_Alerted
+- SFX_Emberwulf_Attack_Bite
+- SFX_Emberwulf_Death
+- SFX_Emberwulf_Hurt
+- SFX_Emberwulf_Run
+- SFX_Emberwulf_Sleep
+- SFX_Emberwulf_Walk
+- SFX_Emit_Forgotten_Whispers
+- SFX_Emit_Lake_Water
+- SFX_Emit_Temple_Wisps
+- SFX_Emit_Tree_Creak
+- SFX_Emit_Wind_Grass
+- SFX_Emit_Wind_Gusts
+- SFX_Env_Emit_Fluid_Lava
+- SFX_Env_Emit_Fluid_Water
+- SFX_Env_Emit_Fluid_Water_Far
+- SFX_Env_Emit_Geyzer
+- SFX_Eye_Void_Alerted
+- SFX_Eye_Void_Attack_Blast
+- SFX_Eye_Void_Attack_Summon
+- SFX_Eye_Void_Death
+- SFX_Eye_Void_Fly_Movement
+- SFX_Eye_Void_Hurt
+- SFX_Eye_Void_Idle
+- SFX_Fen_Stalker_Alerted
+- SFX_Fen_Stalker_Attack_Swing
+- SFX_Fen_Stalker_Attack_Swipe
+- SFX_Fen_Stalker_Death
+- SFX_Fen_Stalker_Eat
+- SFX_Fen_Stalker_Eat_Finish
+- SFX_Fen_Stalker_Greet
+- SFX_Fen_Stalker_Hurt
+- SFX_Fen_Stalker_Run
+- SFX_Fen_Stalker_Scared
+- SFX_Fen_Stalker_Seek
+- SFX_Fen_Stalker_Sniff
+- SFX_Feran_Death
+- SFX_Fern_Break
+- SFX_Fern_MoveIn
+- SFX_Fireball_Bounce
+- SFX_Fireball_Death
+- SFX_Fireball_Miss
+- SFX_Fish_Death
+- SFX_Fish_Flee
+- SFX_Fish_Hurt
+- SFX_Flail_Charge
+- SFX_Flail_Charge_Local
+- SFX_Flail_Swing
+- SFX_Flail_Swing_Left_Local
+- SFX_Flail_Swing_Right_Local
+- SFX_Flame_Break
+- SFX_Flame_Build
+- SFX_Flame_Default_Loop
+- SFX_Flamingo_Alerted
+- SFX_Flamingo_Death
+- SFX_Flamingo_Fly
+- SFX_Flamingo_Hurt
+- SFX_Forgotten_Temple_Emit_Birds
+- SFX_Forgotten_Temple_Emit_Birds_Interior
+- SFX_Fox_Alerted
+- SFX_Fox_Death
+- SFX_Fox_Hurt
+- SFX_Fox_Run
+- SFX_Fox_Sleep
+- SFX_Frog_Alerted
+- SFX_Frog_Croak
+- SFX_Frog_Death
+- SFX_Frog_Hurt
+- SFX_Frog_Idle
+- SFX_Frog_Run
+- SFX_Furnace_Bench_Close
+- SFX_Furnace_Bench_Open
+- SFX_Furnace_Bench_Processing
+- SFX_Furnace_Bench_Processing_Complete
+- SFX_Furnace_Bench_Processing_End
+- SFX_Furnace_Bench_Processing_Failed
+- SFX_Gecko_Alerted
+- SFX_Gecko_Death
+- SFX_Gecko_Hurt
+- SFX_Gem_Break
+- SFX_Gem_Emit_Loop
+- SFX_Generic_Crafting_Failed
+- SFX_Glass_Break
+- SFX_Global_Weather_Thunder
+- SFX_Goat_Run
+- SFX_Goat_Walk
+- SFX_Goblin_Alerted
+- SFX_Goblin_Death
+- SFX_Goblin_Hurt
+- SFX_Goblin_Lobber_Bomb_Bounce
+- SFX_Goblin_Lobber_Bomb_Death
+- SFX_Goblin_Lobber_Bomb_Hit
+- SFX_Goblin_Lobber_Bomb_Miss
+- SFX_Goblin_Run
+- SFX_Goblin_Search
+- SFX_Golem_Earth_Alerted
+- SFX_Golem_Earth_Death
+- SFX_Golem_Earth_Hurt
+- SFX_Golem_Earth_Laydown
+- SFX_Golem_Earth_Slam
+- SFX_Golem_Earth_Slam_Impact
+- SFX_Golem_Earth_Spin
+- SFX_Golem_Earth_Stomp
+- SFX_Golem_Earth_Stomp_Impact
+- SFX_Golem_Earth_Swing
+- SFX_Golem_Earth_Swing_Impact
+- SFX_Golem_Earth_Wake
+- SFX_Golem_Firesteel_Alerted_01
+- SFX_Golem_Firesteel_Alerted_02
+- SFX_Golem_Firesteel_Death
+- SFX_Golem_Firesteel_Laydown
+- SFX_Golem_Firesteel_Wake
+- SFX_Golem_Frost_Alerted
+- SFX_Golem_Frost_Death
+- SFX_Golem_Frost_Hurt
+- SFX_Golem_Frost_Laydown
+- SFX_Golem_Frost_Slam
+- SFX_Golem_Frost_Slam_Impact
+- SFX_Golem_Frost_Spin
+- SFX_Golem_Frost_Stomp
+- SFX_Golem_Frost_Swing
+- SFX_Golem_Frost_Swing_Impact
+- SFX_Golem_Frost_Wake
+- SFX_Golem_Sand_Alerted
+- SFX_Golem_Sand_Death
+- SFX_Golem_Sand_Hurt
+- SFX_Golem_Sand_Laydown
+- SFX_Golem_Sand_Slam
+- SFX_Golem_Sand_Slam_Impact
+- SFX_Golem_Sand_Spin
+- SFX_Golem_Sand_Stomp
+- SFX_Golem_Sand_Stomp_Impact
+- SFX_Golem_Sand_Swing
+- SFX_Golem_Sand_Swing_Impact
+- SFX_Golem_Sand_Wake
+- SFX_Grass_Break
+- SFX_Grass_Build
+- SFX_Grass_Hit
+- SFX_Grass_Land
+- SFX_Grass_Walk
+- SFX_Gravel_Break
+- SFX_Gravel_Build
+- SFX_Gravel_Hit
+- SFX_Gravel_Land
+- SFX_Gravel_Walk
+- SFX_GunPvP_Assault_Rifle_Bullet_Death
+- SFX_GunPvP_Grenade_Frag_Bounce
+- SFX_GunPvP_Grenade_Frag_Death
+- SFX_GunPvP_Grenade_Frag_Hit
+- SFX_GunPvP_Grenade_Frag_Miss
+- SFX_GunPvP_Handgun_Bullet_Death
+- SFX_Gun_Fire
+- SFX_Hand_Crossbow_T1_Block_Impact
+- SFX_Hand_Crossbow_T1_Raise
+- SFX_Hand_Crossbow_T1_Raise_Local
+- SFX_Hand_Crossbow_T1_Shove
+- SFX_Hand_Crossbow_T1_Shove_Local
+- SFX_Hand_Crossbow_T2_Load
+- SFX_Hand_Crossbow_T2_Load_Local
+- SFX_Hand_Crossbow_T2_Reload_Start
+- SFX_Hand_Crossbow_T2_Reload_Start_Local
+- SFX_Handgun_Fire
+- SFX_Handgun_Fire_Local
+- SFX_Hatchet_T1_Swing_RL_Local
+- SFX_Hatchet_T2_Impact_Nice
+- SFX_Health_Potion_High_Drink
+- SFX_Health_Potion_High_Drink_Local
+- SFX_Health_Potion_Low_Drink
+- SFX_Health_Potion_Low_Drink_Local
+- SFX_Hedera_Scream
+- SFX_Hoe_T1_Swing_Down_Local
+- SFX_Hoe_T1_Till
+- SFX_Horse_Alerted
+- SFX_Horse_Death
+- SFX_Horse_Hurt
+- SFX_Horse_Idle
+- SFX_Horse_Sleep
+- SFX_Horse_Wake
+- SFX_Hyena_Alerted
+- SFX_Hyena_Death
+- SFX_Hyena_Hurt
+- SFX_Hyena_Idle
+- SFX_Ice_Ball_Death
+- SFX_Ice_Bolt_Death
+- SFX_Ice_Break
+- SFX_Ice_Build
+- SFX_Ice_Hit
+- SFX_Ice_Item_Impact
+- SFX_Ice_Item_Swing
+- SFX_Ice_Land
+- SFX_Ice_Walk
+- SFX_Incorrect_Tool
+- SFX_Item_Break
+- SFX_Item_Repair
+- SFX_Klops_Alerted
+- SFX_Klops_Death
+- SFX_Klops_Hurt
+- SFX_Klops_Idle
+- SFX_Klops_Run
+- SFX_Kweebec_Plushie_Impact
+- SFX_Lamb_Alerted
+- SFX_Lamb_Death
+- SFX_Lamb_Hurt
+- SFX_Larva_Alerted
+- SFX_Larva_Death
+- SFX_Larva_Despawn
+- SFX_Larva_Hurt
+- SFX_Larva_Spawn
+- SFX_LeavesGround_Break
+- SFX_LeavesGround_Hit
+- SFX_LeavesGround_Land
+- SFX_LeavesGround_Walk
+- SFX_Leaves_Break
+- SFX_Leaves_Hit
+- SFX_Leaves_Walk
+- SFX_Leopard_Snow_Alerted
+- SFX_Leopard_Snow_Death
+- SFX_Leopard_Snow_Hurt
+- SFX_Leopard_Snow_Run
+- SFX_Light_Melee_T1_Block
+- SFX_Light_Melee_T1_Guard_Hit
+- SFX_Light_Melee_T1_Impact
+- SFX_Light_Melee_T1_Lunge
+- SFX_Light_Melee_T1_Lunge_Charge
+- SFX_Light_Melee_T1_Shove
+- SFX_Light_Melee_T1_Swing
+- SFX_Light_Melee_T2_Block
+- SFX_Light_Melee_T2_Guard_Break
+- SFX_Light_Melee_T2_Guard_Hit
+- SFX_Light_Melee_T2_Lunge
+- SFX_Light_Melee_T2_Lunge_Charge
+- SFX_Light_Melee_T2_Swing
+- SFX_Longsword_Special_Impact
+- SFX_Longsword_Special_Swing
+- SFX_Longsword_Steel_Charged_Swing
+- SFX_Longsword_Steel_Impact
+- SFX_Longsword_Steel_Swing
+- SFX_Lumbermill_Bench_Close
+- SFX_Lumbermill_Bench_Open
+- SFX_Lumbermill_Bench_Processing
+- SFX_Mace_T1_Block_Impact
+- SFX_Mace_T1_Impact
+- SFX_Mace_T1_Raise
+- SFX_Mace_T1_Raise_Local
+- SFX_Mace_T1_Shove
+- SFX_Mace_T1_Shove_Local
+- SFX_Mace_T1_Swing
+- SFX_Mace_T1_Swing_Charged
+- SFX_Mace_T1_Swing_Charged_LR_Local
+- SFX_Mace_T1_Swing_Charged_RL_Local
+- SFX_Mace_T1_Swing_Charged_Up_Local
+- SFX_Mace_T1_Swing_LR_Local
+- SFX_Mace_T1_Swing_RL_Local
+- SFX_Mace_T1_Swing_Up_Local
+- SFX_Mace_T2_Impact
+- SFX_Mace_T2_Raise
+- SFX_Mace_T2_Raise_Local
+- SFX_Mace_T2_Signature_Impact
+- SFX_Mace_T2_Signature_Impact_Local
+- SFX_Mace_T2_Signature_Launch
+- SFX_Mace_T2_Signature_Launch_Local
+- SFX_Mace_T2_Swing
+- SFX_Mace_T2_Swing_Charged
+- SFX_Mace_T2_Swing_Charged_LR_Local
+- SFX_Mace_T2_Swing_Charged_RL_Local
+- SFX_Mace_T2_Swing_Charged_Up_Local
+- SFX_Mace_T2_Swing_LR_Local
+- SFX_Mace_T2_Swing_RL_Local
+- SFX_Mace_T2_Swing_Up_Local
+- SFX_Meerkat_Alerted
+- SFX_Meerkat_Death
+- SFX_Meerkat_Hurt
+- SFX_Meerkat_Idle
+- SFX_Memories_Unlock_Local
+- SFX_Metal_Break
+- SFX_Metal_Build
+- SFX_Metal_Hit
+- SFX_Metal_Land
+- SFX_Metal_Walk
+- SFX_Moose_Bull_Alerted
+- SFX_Mouse_Alerted
+- SFX_Mouse_Death
+- SFX_Mouse_Flee
+- SFX_Mouse_Hurt
+- SFX_Mouse_Run
+- SFX_Mouse_Sleep
+- SFX_Mud_Break
+- SFX_Mud_Build
+- SFX_Mud_Hit
+- SFX_Mud_Land
+- SFX_Mud_Walk
+- SFX_Mug_Fill
+- SFX_Mug_Fill_Local
+- SFX_Mushroom_Break
+- SFX_Mushroom_Harvest
+- SFX_Music_Ducking_2db
+- SFX_NPC_Unarmed_Impact
+- SFX_NPC_Unarmed_Swing
+- SFX_Ore_Break
+- SFX_Ore_Hit
+- SFX_Outlander_Hunter_Arrow_Hit
+- SFX_Outlander_Hunter_Arrow_Miss
+- SFX_Outlander_Hurt
+- SFX_Owl_Alerted
+- SFX_Owl_Death
+- SFX_Owl_Hurt
+- SFX_Pickaxe_T1_Swing_Down_Local
+- SFX_Pickaxe_T2_Impact_Nice
+- SFX_Pig_Alerted
+- SFX_Pig_Death
+- SFX_Pig_Hurt
+- SFX_Pig_Run
+- SFX_Pig_Walk
+- SFX_Pigeon_Death
+- SFX_Pigeon_Hurt
+- SFX_Piglet_Alerted
+- SFX_Piglet_Death
+- SFX_Piglet_Hurt
+- SFX_Piglet_Run
+- SFX_Pistol_Fire
+- SFX_Plant_Break
+- SFX_Plant_Hit
+- SFX_Plant_MoveIn
+- SFX_Player_Climb_Down
+- SFX_Player_Climb_Side
+- SFX_Player_Climb_Up
+- SFX_Player_Craft_Item_Inventory
+- SFX_Player_Death
+- SFX_Player_Death_Drown
+- SFX_Player_Death_Fall
+- SFX_Player_Drop_Item
+- SFX_Player_Fall
+- SFX_Player_Glide_Motion
+- SFX_Player_Glide_Stationary
+- SFX_Player_Grab_Item
+- SFX_Player_Hurt
+- SFX_Player_Hurt_Burn
+- SFX_Player_Hurt_Drowning
+- SFX_Player_Hurt_Fall
+- SFX_Player_Jump
+- SFX_Player_Mantle
+- SFX_Player_Pickup_Item
+- SFX_Player_Roll
+- SFX_Player_Slide
+- SFX_Player_Swim
+- SFX_Player_Swim_Fast
+- SFX_Player_Swim_Jump
+- SFX_Player_Unarmed_Swing_Left
+- SFX_Player_Unarmed_Swing_Right
+- SFX_Plushie_Break
+- SFX_Plushie_Build
+- SFX_Poop_Bounce
+- SFX_Poop_Break
+- SFX_Poop_Hit
+- SFX_Poop_Walk
+- SFX_Portal_Neutral
+- SFX_Portal_Neutral_Open
+- SFX_Portal_Neutral_Teleport_Local
+- SFX_Portal_Void
+- SFX_Potion_Drink_Success
+- SFX_Processing_Placeholder
+- SFX_Projectile_Poop_Hit
+- SFX_Rabbit_Alerted
+- SFX_Rabbit_Death
+- SFX_Rabbit_Hurt
+- SFX_Rabbit_Run
+- SFX_Rabbit_Sleep
+- SFX_Ram_Alerted
+- SFX_Ram_Death
+- SFX_Ram_Hurt
+- SFX_Ram_Run
+- SFX_Ram_Sleep
+- SFX_Raptor_Cave_Alerted
+- SFX_Raptor_Cave_Idle
+- SFX_Rat_Death
+- SFX_Rat_Hurt
+- SFX_Raven_Alerted
+- SFX_Raven_Death
+- SFX_Raven_Flee
+- SFX_Raven_Hurt
+- SFX_Reeds_MoveIn
+- SFX_Rifle_Fire
+- SFX_Rifle_Fire_Local
+- SFX_Rope_Break
+- SFX_Rope_Build
+- SFX_Rope_Land
+- SFX_Rope_Walk
+- SFX_Rotate_Pitch_Default
+- SFX_Rotate_Roll_Default
+- SFX_Rotate_Yaw_Default
+- SFX_Rubble_Bounce
+- SFX_Rubble_Hit
+- SFX_Sand_Break
+- SFX_Sand_Build
+- SFX_Sand_Hit
+- SFX_Sand_Land
+- SFX_Sand_Walk
+- SFX_Scarak_Fighter_Alerted
+- SFX_Scarak_Fighter_Death
+- SFX_Scarak_Fighter_Hurt
+- SFX_Scarak_Seeker_Alerted
+- SFX_Scarak_Seeker_Death
+- SFX_Scarak_Seeker_Hurt
+- SFX_Scarak_Seeker_Spitball_Death
+- SFX_Scarak_Spitball_Fire
+- SFX_Scorpion_Alerted
+- SFX_Scorpion_Death
+- SFX_Scorpion_Run
+- SFX_Scorpion_Threaten
+- SFX_Seeds_Place
+- SFX_Shark_Death
+- SFX_Shark_Dive
+- SFX_Shark_Hurt
+- SFX_Shark_Swim
+- SFX_Shears_Activate
+- SFX_Sheep_Alerted
+- SFX_Sheep_Death
+- SFX_Sheep_Hurt
+- SFX_Sheep_Run
+- SFX_Sheep_Sheared
+- SFX_Sheep_Walk
+- SFX_Shield_T1_Break
+- SFX_Shield_T1_Impact
+- SFX_Shield_T1_Raise
+- SFX_Shield_T1_Raise_Local
+- SFX_Shield_T1_Swing
+- SFX_Shield_T1_Swing_Local
+- SFX_Shield_T2_Impact
+- SFX_Shield_T2_Raise
+- SFX_Shield_T2_Raise_Local
+- SFX_Shield_T2_Swing
+- SFX_Shield_T2_Swing_Local
+- SFX_Shovel_T1_Swing_RL_Local
+- SFX_Shovel_T2_Impact_Nice
+- SFX_Skeleton_Alerted
+- SFX_Skeleton_Death_1
+- SFX_Skeleton_Death_2
+- SFX_Skeleton_Death_3
+- SFX_Skeleton_Death_4
+- SFX_Skeleton_Despawn_1
+- SFX_Skeleton_Despawn_2
+- SFX_Skeleton_Hurt
+- SFX_Skeleton_Mage_Spellbook_Charge
+- SFX_Skeleton_Mage_Spellbook_Impact
+- SFX_Skeleton_Praetorian_Alerted
+- SFX_Skeleton_Praetorian_Death_1
+- SFX_Skeleton_Praetorian_Death_2
+- SFX_Skeleton_Praetorian_Death_3
+- SFX_Skeleton_Praetorian_Death_4
+- SFX_Skeleton_Praetorian_Despawn_1
+- SFX_Skeleton_Praetorian_Despawn_2
+- SFX_Skeleton_Praetorian_Hurt
+- SFX_Skeleton_Praetorian_Run
+- SFX_Skeleton_Praetorian_Search_2
+- SFX_Skeleton_Praetorian_Spawn_1
+- SFX_Skeleton_Praetorian_Walk
+- SFX_Skeleton_Run
+- SFX_Skeleton_Search_2
+- SFX_Skeleton_Spawn_1
+- SFX_Skeleton_Spawn_2
+- SFX_Skeleton_Walk
+- SFX_Snake_Alerted
+- SFX_Snake_Death
+- SFX_Snake_Hurt
+- SFX_Snake_Idle
+- SFX_Snow_Break
+- SFX_Snow_Build
+- SFX_Snow_Hit
+- SFX_Snow_Land
+- SFX_Snow_Walk
+- SFX_Soft_Break
+- SFX_Soft_Build
+- SFX_Soft_Hit
+- SFX_Soft_Land
+- SFX_Soft_Walk
+- SFX_Spark_Living_Alerted
+- SFX_Spark_Living_Death
+- SFX_Sparrow_Alerted
+- SFX_Sparrow_Death
+- SFX_Sparrow_Hurt
+- SFX_Sparrow_Idle
+- SFX_Spawn_Void_Alerted
+- SFX_Spawn_Void_Attack
+- SFX_Spawn_Void_Death
+- SFX_Spawn_Void_Hurt
+- SFX_Spawn_Void_Run
+- SFX_Spear_Impact
+- SFX_Spear_Lunge
+- SFX_Spear_Lunge_Local
+- SFX_Spear_Miss
+- SFX_Spear_Projectile_Impact
+- SFX_Spear_Throw
+- SFX_Spear_Throw_Charge
+- SFX_Spear_Throw_Charge_Local
+- SFX_Spear_Throw_Local
+- SFX_Spider_Alerted
+- SFX_Spider_Death
+- SFX_Spider_Run
+- SFX_Spirit_Root_Alerted
+- SFX_Spirit_Root_Death_01
+- SFX_Spirit_Root_Death_02
+- SFX_Spirit_Root_Hurt
+- SFX_Spirit_Root_Spawn
+- SFX_Squirrel_Alerted
+- SFX_Squirrel_Death
+- SFX_Squirrel_Hurt
+- SFX_Squirrel_Run
+- SFX_Staff_Charged_Loop
+- SFX_Staff_Fire_Shoot
+- SFX_Staff_Flame_Consume_Charge_1
+- SFX_Staff_Flame_Consume_Charge_1_Local
+- SFX_Staff_Flame_Consume_Charge_2
+- SFX_Staff_Flame_Consume_Charge_2_Local
+- SFX_Staff_Flame_Consume_Charge_3
+- SFX_Staff_Flame_Consume_Charge_3_Local
+- SFX_Staff_Flame_Consume_Charge_4
+- SFX_Staff_Flame_Consume_Charge_4_Local
+- SFX_Staff_Flame_Fireball_Impact
+- SFX_Staff_Flame_Fireball_Launch
+- SFX_Staff_Flame_Fireball_Launch_Local
+- SFX_Staff_Flame_Flamethrower
+- SFX_Staff_Flame_Flamethrower_End
+- SFX_Staff_Flame_Flamethrower_End_Local
+- SFX_Staff_Flame_Flamethrower_Impact
+- SFX_Staff_Flame_Flamethrower_Local
+- SFX_Staff_Flame_Trap_Deploy
+- SFX_Staff_Flame_Trap_Despawn
+- SFX_Staff_Flame_Trap_Loop
+- SFX_Staff_Ice_Shoot
+- SFX_Stamina_Potion_Success
+- SFX_Sticks_Break
+- SFX_Stone_Break
+- SFX_Stone_Build
+- SFX_Stone_Coffin_Open_Close
+- SFX_Stone_Harvest
+- SFX_Stone_Hit
+- SFX_Stone_Land
+- SFX_Stone_Walk
+- SFX_Sword_T1_Block_Local
+- SFX_Sword_T1_Lunge_Charge_Local
+- SFX_Sword_T1_Lunge_Local
+- SFX_Sword_T1_Shove_Local
+- SFX_Sword_T1_Swing_Down_Local
+- SFX_Sword_T1_Swing_LR_Local
+- SFX_Sword_T1_Swing_RL_Local
+- SFX_Sword_T2_Block_Local
+- SFX_Sword_T2_Impact
+- SFX_Sword_T2_Lunge_Charge_Local
+- SFX_Sword_T2_Lunge_Local
+- SFX_Sword_T2_Signature_Part_1
+- SFX_Sword_T2_Signature_Part_1_Local
+- SFX_Sword_T2_Signature_Part_2
+- SFX_Sword_T2_Signature_Part_2_Local
+- SFX_Sword_T2_Swing_Down_Local
+- SFX_Sword_T2_Swing_LR_Local
+- SFX_Sword_T2_Swing_RL_Local
+- SFX_T1_Impact_Blunt
+- SFX_Tall_Grass_MoveIn
+- SFX_Test_Blip_A
+- SFX_Test_Blip_B
+- SFX_Test_Blip_C
+- SFX_Tetrabird_Alerted
+- SFX_Tetrabird_Death
+- SFX_Tetrabird_Flee
+- SFX_Tetrabird_Hurt
+- SFX_Tetrabird_Run
+- SFX_Tiger_Sabertooth_Alerted
+- SFX_Tiger_Sabertooth_Death
+- SFX_Tiger_Sabertooth_Hurt
+- SFX_Tiger_Sabertooth_Run
+- SFX_Toad_Rhino_Alerted
+- SFX_Toad_Rhino_Death
+- SFX_Toad_Rhino_Hurt
+- SFX_Toad_Rhino_Magma_Alerted
+- SFX_Toad_Rhino_Magma_Death
+- SFX_Toad_Rhino_Magma_Hurt
+- SFX_Toad_Rhino_Magma_Run
+- SFX_Toad_Rhino_Magma_Tongue_Impact
+- SFX_Toad_Rhino_Magma_Tongue_Whoosh
+- SFX_Toad_Rhino_Run
+- SFX_Toad_Rhino_Tongue_Impact
+- SFX_Toad_Rhino_Tongue_Whoosh
+- SFX_Tombstone_Break
+- SFX_Tool_T1_Swing
+- SFX_Tool_Watering_Can_Water
+- SFX_Torch_Break
+- SFX_Torch_Build
+- SFX_Torch_Default_Loop
+- SFX_Torch_Impact
+- SFX_Torch_Off
+- SFX_Torch_On_Loop
+- SFX_Torch_Swing
+- SFX_Torch_Swing_Left_Local
+- SFX_Torch_Swing_Right_Local
+- SFX_Tornado
+- SFX_Trashpile_Land
+- SFX_Trashpile_Walk
+- SFX_Trork_Alerted
+- SFX_Trork_Chieftain_Alerted
+- SFX_Trork_Chieftain_Death
+- SFX_Trork_Chieftain_Hurt
+- SFX_Trork_Chieftain_Run
+- SFX_Trork_Chieftain_Search
+- SFX_Trork_Death
+- SFX_Trork_Exertion
+- SFX_Trork_Hurt_01
+- SFX_Trork_Hurt_02
+- SFX_Trork_Run
+- SFX_Trork_Search
+- SFX_Trork_Sleep
+- SFX_Trork_Throwing_Axe
+- SFX_Unarmed_Impact
+- SFX_Unarmed_Swing
+- SFX_Unbreakable_Block
+- SFX_Vulture_Alerted
+- SFX_Vulture_Death
+- SFX_Vulture_Flee
+- SFX_Vulture_Hurt
+- SFX_Wand_Fire_Shoot
+- SFX_Wand_Ice_Shoot
+- SFX_Warthog_Alerted
+- SFX_Warthog_Death
+- SFX_Warthog_Hurt
+- SFX_Warthog_Piglet_Alerted
+- SFX_Warthog_Piglet_Death
+- SFX_Warthog_Piglet_Hurt
+- SFX_Warthog_Piglet_Run
+- SFX_Warthog_Run
+- SFX_Warthog_Sleep
+- SFX_Warthog_Walk
+- SFX_Water_MoveIn
+- SFX_Water_MoveOut
+- SFX_Weapon_Bench_Close
+- SFX_Weapon_Bench_Craft
+- SFX_Weapon_Bench_Open
+- SFX_Weapon_Charge_Swing
+- SFX_Web_MoveIn
+- SFX_Window_Break
+- SFX_Window_Stone_Break
+- SFX_Wisp_Lamp_Loop
+- SFX_Wolf_Alerted
+- SFX_Wolf_Death
+- SFX_Wolf_Hurt
+- SFX_Wolf_Run
+- SFX_Wolf_Sleep
+- SFX_Wood_Break
+- SFX_Wood_Build
+- SFX_Wood_Hit
+- SFX_Wood_Land
+- SFX_Wood_Walk
+- SFX_Woodpecker_Death
+- SFX_Woodpecker_Hurt
+- SFX_Workbench_Close
+- SFX_Workbench_Craft
+- SFX_Workbench_Open
+- SFX_Workbench_Upgrade_Complete_Default
+- SFX_Workbench_Upgrade_Start_Default
+- SFX_Yeti_Alerted
+- SFX_Z1_Emit_Forest_Autumn_Day_Birds
+- SFX_Z1_Emit_Forest_Autumn_Day_Insects
+- SFX_Z1_Emit_Forest_Autumn_Day_Wind
+- SFX_Z1_Emit_Forest_Azure_Day_Insects
+- SFX_Z1_Emit_Forest_Azure_Day_Wind
+- SFX_Z1_Emit_Forest_Gen_Day_Birds
+- SFX_Z1_Emit_Forest_Gen_Day_Insects
+- SFX_Z1_Emit_Forest_Gen_Day_Winds
+- SFX_Z1_Emit_Forest_Moss_Day_Birds
+- SFX_Z1_Emit_Forest_Moss_Day_Insects
+- SFX_Z1_Emit_Forest_Moss_Day_Wind
+- SFX_Z1_Emit_Forest_Night_Birds
+- SFX_Z1_Emit_Forest_Night_Insects
+- SFX_Z1_Emit_Forest_Night_Wind
+- SFX_Z1_Emit_Kweebec_Village_Wind
+- SFX_Z1_Emit_Mountain_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Insects
+- SFX_Z1_Emit_Plains_Gen_Day_Wind
+- SFX_Z1_Emit_Plains_Gen_Night_Birds
+- SFX_Z1_Emit_Plains_Gen_Night_Insects
+- SFX_Z1_Emit_Plains_Gen_Night_Wind
+- SFX_Z1_Emit_Shore_Day_Birds
+- SFX_Z1_Emit_Shore_Waves
+- SFX_Z1_Emit_Shore_Wind
+- SFX_Z1_Emit_Swamp_Day_Birds
+- SFX_Z1_Emit_Swamp_Day_Frogs
+- SFX_Z1_Emit_Swamp_Day_Insects
+- SFX_Z1_Emit_Swamp_Day_Wind
+- SFX_Z1_Emit_Swamp_Night_Frogs
+- SFX_Z1_Emit_Trork_Camp
+- SFX_Z1_Shore_Day_Birds
+- SFX_Z3_Emit_Cave_Ice_Crackle
+- SFX_Z3_Emit_Cave_Ice_Rumble
+- SFX_Z3_Emit_Cave_Ice_Stress
+- SFX_Z3_Emit_Cave_Snow_Crackle
+- SFX_Z3_Emit_Cave_Snow_Melt
+- SFX_Z3_Emit_Hedera_FX
+- SFX_Z3_Emit_Hedera_PlantRustle
+- SFX_Z3_Emit_Tree_Creak
+- SFX_Z3_Emit_Wind_Leaves
+- SFX_Z3_Emit_Wind_Leaves_Stereo
+- SFX_Z3_Forest_Day_Birds
+- SFX_Z3_Forest_Day_General
+- SFX_Z3_Forest_Night_Birds
+- SFX_Zombie_Alerted
+- SFX_Zombie_Attack_Bite
+- SFX_Zombie_Attack_Swing
+- SFX_Zombie_Death
+- SFX_Zombie_Despawn
+- SFX_Zombie_Hurt
+- SFX_Zombie_Pursuit
+- SFX_Zombie_ScratchBack
+- SFX_Zombie_Spawn
diff --git a/content/docs/da-DK/guides/ecs/entity-component-system.mdx b/content/docs/da-DK/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/da-DK/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/da-DK/guides/ecs/example-ecs-plugin.mdx b/content/docs/da-DK/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/da-DK/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/da-DK/guides/ecs/hytale-ecs-theory.mdx b/content/docs/da-DK/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/da-DK/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/da-DK/guides/ecs/systems.mdx b/content/docs/da-DK/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/da-DK/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/da-DK/guides/java-basics/00-introduction.mdx b/content/docs/da-DK/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/da-DK/guides/java-basics/00-introduction.mdx
+++ b/content/docs/da-DK/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/da-DK/guides/java-basics/06-methods-functions.mdx b/content/docs/da-DK/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/da-DK/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/da-DK/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/da-DK/guides/plugin/block-components.mdx b/content/docs/da-DK/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/da-DK/guides/plugin/browsing-serverjar.mdx b/content/docs/da-DK/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/da-DK/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/da-DK/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/da-DK/guides/plugin/build-and-test.mdx b/content/docs/da-DK/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/da-DK/guides/plugin/chat-formatting.mdx b/content/docs/da-DK/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/da-DK/guides/plugin/chat-formatting.mdx
+++ b/content/docs/da-DK/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/da-DK/guides/plugin/client-inputs-reference.mdx b/content/docs/da-DK/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/da-DK/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/da-DK/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/da-DK/guides/plugin/creating-block.mdx b/content/docs/da-DK/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/da-DK/guides/plugin/creating-block.mdx
+++ b/content/docs/da-DK/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/da-DK/guides/plugin/creating-commands.mdx b/content/docs/da-DK/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/da-DK/guides/plugin/creating-commands.mdx
+++ b/content/docs/da-DK/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/da-DK/guides/plugin/creating-configuration-file.mdx b/content/docs/da-DK/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/da-DK/guides/plugin/creating-events.mdx b/content/docs/da-DK/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/da-DK/guides/plugin/creating-events.mdx
+++ b/content/docs/da-DK/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/da-DK/guides/plugin/customizing-camera-controls.mdx b/content/docs/da-DK/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/da-DK/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/da-DK/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/da-DK/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/da-DK/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/da-DK/guides/plugin/instances.mdx b/content/docs/da-DK/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/da-DK/guides/plugin/inventory-management.mdx b/content/docs/da-DK/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/da-DK/guides/plugin/inventory-management.mdx
+++ b/content/docs/da-DK/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/da-DK/guides/plugin/item-interaction.mdx b/content/docs/da-DK/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/da-DK/guides/plugin/listening-to-packets.mdx b/content/docs/da-DK/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/da-DK/guides/plugin/logging.mdx b/content/docs/da-DK/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/da-DK/guides/plugin/player-death-event.mdx b/content/docs/da-DK/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/da-DK/guides/plugin/player-input-guide.mdx b/content/docs/da-DK/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/da-DK/guides/plugin/player-input-guide.mdx
+++ b/content/docs/da-DK/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/da-DK/guides/plugin/player-stats.mdx b/content/docs/da-DK/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/da-DK/guides/plugin/setting-up-env.mdx b/content/docs/da-DK/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/da-DK/guides/plugin/setting-up-env.mdx
+++ b/content/docs/da-DK/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/da-DK/guides/plugin/spawning-entities.mdx b/content/docs/da-DK/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/da-DK/guides/plugin/spawning-entities.mdx
+++ b/content/docs/da-DK/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/da-DK/guides/plugin/spawning-npcs.mdx b/content/docs/da-DK/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/da-DK/guides/plugin/store-persistant-data.mdx b/content/docs/da-DK/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/da-DK/guides/plugin/teleporting-players.mdx b/content/docs/da-DK/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/da-DK/guides/plugin/teleporting-players.mdx
+++ b/content/docs/da-DK/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/da-DK/guides/plugin/text-hologram.mdx b/content/docs/da-DK/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/da-DK/guides/plugin/ui.mdx b/content/docs/da-DK/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/da-DK/guides/plugin/world-gen.mdx b/content/docs/da-DK/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/da-DK/guides/plugin/world-gen.mdx
+++ b/content/docs/da-DK/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/da-DK/guides/prefabs.mdx b/content/docs/da-DK/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/da-DK/guides/prefabs.mdx
+++ b/content/docs/da-DK/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/da-DK/official-documentation/npc-doc.mdx b/content/docs/da-DK/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/da-DK/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/da-DK/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/da-DK/publishing/builtbybit.mdx b/content/docs/da-DK/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/da-DK/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/da-DK/publishing/index.mdx b/content/docs/da-DK/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/da-DK/publishing/index.mdx
+++ b/content/docs/da-DK/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/de-DE/guides/ecs/entity-component-system.mdx b/content/docs/de-DE/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/de-DE/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/de-DE/guides/ecs/example-ecs-plugin.mdx b/content/docs/de-DE/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/de-DE/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/de-DE/guides/ecs/hytale-ecs-theory.mdx b/content/docs/de-DE/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/de-DE/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/de-DE/guides/ecs/systems.mdx b/content/docs/de-DE/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/de-DE/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/de-DE/guides/java-basics/00-introduction.mdx b/content/docs/de-DE/guides/java-basics/00-introduction.mdx
index 39597e77..82e744d3 100644
--- a/content/docs/de-DE/guides/java-basics/00-introduction.mdx
+++ b/content/docs/de-DE/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Bevor wir in die Programmierung eintauchen können, musst du ein paar notwendige
 
 ### Java Development Kit (JDK)
 
-Lade dir JDK 25 von der [offiziellen Oracle Website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) herunter oder verwenden eine Open-Source Alternative wie [AdoptOpenJDK](https://adoptopenjdk.net/) und installiere diese.
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Integrierte Entwicklungsumgebung (IDE)
+### Integrated Development Environment (IDE)
 
 Eine IDE ist eine Software-Anwendung, die Programmierern umfassende Möglichkeiten für die Softwareentwicklung bietet. Beliebte Optionen für Java beinhalten:
 
diff --git a/content/docs/de-DE/guides/java-basics/06-methods-functions.mdx b/content/docs/de-DE/guides/java-basics/06-methods-functions.mdx
index 0f90d0a6..a421a4c4 100644
--- a/content/docs/de-DE/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/de-DE/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Enthält mindestens eine Zahl
    * Gibt true zurück wenn gültig, ansonsten false
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Häufige Fehler
 
 ```java
diff --git a/content/docs/de-DE/guides/plugin/block-components.mdx b/content/docs/de-DE/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/de-DE/guides/plugin/browsing-serverjar.mdx b/content/docs/de-DE/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/de-DE/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/de-DE/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/de-DE/guides/plugin/build-and-test.mdx b/content/docs/de-DE/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/de-DE/guides/plugin/chat-formatting.mdx b/content/docs/de-DE/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/de-DE/guides/plugin/chat-formatting.mdx
+++ b/content/docs/de-DE/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/de-DE/guides/plugin/client-inputs-reference.mdx b/content/docs/de-DE/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/de-DE/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/de-DE/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/de-DE/guides/plugin/creating-block.mdx b/content/docs/de-DE/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/de-DE/guides/plugin/creating-block.mdx
+++ b/content/docs/de-DE/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/de-DE/guides/plugin/creating-commands.mdx b/content/docs/de-DE/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/de-DE/guides/plugin/creating-commands.mdx
+++ b/content/docs/de-DE/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/de-DE/guides/plugin/creating-configuration-file.mdx b/content/docs/de-DE/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/de-DE/guides/plugin/creating-events.mdx b/content/docs/de-DE/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/de-DE/guides/plugin/creating-events.mdx
+++ b/content/docs/de-DE/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/de-DE/guides/plugin/customizing-camera-controls.mdx b/content/docs/de-DE/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/de-DE/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/de-DE/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/de-DE/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/de-DE/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/de-DE/guides/plugin/instances.mdx b/content/docs/de-DE/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/de-DE/guides/plugin/inventory-management.mdx b/content/docs/de-DE/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/de-DE/guides/plugin/inventory-management.mdx
+++ b/content/docs/de-DE/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/de-DE/guides/plugin/item-interaction.mdx b/content/docs/de-DE/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/de-DE/guides/plugin/listening-to-packets.mdx b/content/docs/de-DE/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/de-DE/guides/plugin/logging.mdx b/content/docs/de-DE/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/de-DE/guides/plugin/player-death-event.mdx b/content/docs/de-DE/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/de-DE/guides/plugin/player-input-guide.mdx b/content/docs/de-DE/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/de-DE/guides/plugin/player-input-guide.mdx
+++ b/content/docs/de-DE/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/de-DE/guides/plugin/player-stats.mdx b/content/docs/de-DE/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/de-DE/guides/plugin/setting-up-env.mdx b/content/docs/de-DE/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/de-DE/guides/plugin/setting-up-env.mdx
+++ b/content/docs/de-DE/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/de-DE/guides/plugin/spawning-entities.mdx b/content/docs/de-DE/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/de-DE/guides/plugin/spawning-entities.mdx
+++ b/content/docs/de-DE/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/de-DE/guides/plugin/spawning-npcs.mdx b/content/docs/de-DE/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/de-DE/guides/plugin/store-persistant-data.mdx b/content/docs/de-DE/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/de-DE/guides/plugin/teleporting-players.mdx b/content/docs/de-DE/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/de-DE/guides/plugin/teleporting-players.mdx
+++ b/content/docs/de-DE/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/de-DE/guides/plugin/text-hologram.mdx b/content/docs/de-DE/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/de-DE/guides/plugin/ui.mdx b/content/docs/de-DE/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/de-DE/guides/plugin/world-gen.mdx b/content/docs/de-DE/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/de-DE/guides/plugin/world-gen.mdx
+++ b/content/docs/de-DE/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/de-DE/guides/prefabs.mdx b/content/docs/de-DE/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/de-DE/guides/prefabs.mdx
+++ b/content/docs/de-DE/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/de-DE/official-documentation/npc-doc.mdx b/content/docs/de-DE/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/de-DE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/de-DE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/de-DE/publishing/builtbybit.mdx b/content/docs/de-DE/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/de-DE/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/de-DE/publishing/index.mdx b/content/docs/de-DE/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/de-DE/publishing/index.mdx
+++ b/content/docs/de-DE/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/es-ES/contributing/index.mdx b/content/docs/es-ES/contributing/index.mdx
index ac05eb21..1a80505c 100644
--- a/content/docs/es-ES/contributing/index.mdx
+++ b/content/docs/es-ES/contributing/index.mdx
@@ -1,39 +1,39 @@
 ---
-title: Contributing
+title: Contribuir
 ---
 
-# Contributing to HytaleModding
+# Contribuir a HytaleModding
 
-We welcome contributions from the community to help improve and expand the HytaleModding documentation. Whether you're fixing typos, adding new tutorials, or providing code examples, your contributions are valuable!
+Te damos la bienvenida a las contribuciones de la comunidad para ayudar a mejorar y ampliar la documentación de HytaleModding. Ya sea que estés corrigiendo errores tipográficos, añadiendo nuevos tutoriales o proporcionando ejemplos de código, ¡tus aportaciones son valiosas!
 
-## How to Contribute
+## Cómo contribuir
 
-### Reporting Issues
+### Reportar problemas
 
-If you've found a issue with the documentation, please report it by opening a new issue on our [GitHub repository](https://github.com/HytaleModding/site/issues).
+Si has encontrado un problema en la documentación, notifícalo abriendo una nueva incidencia en nuestro [Repositorio GitHub] (https://github.com/HytaleModding/site/issues).
 
-If you can work on this issue yourself, you can ask to be assigned to it and submit a PR.
+Si puedes trabajar en este problema por tu cuenta, puedes pedir que te lo asignen y enviar un PR.
 
-### Submitting Pull Requests
+### Envío de solicitudes de incorporación de cambios
 
-1. Fork the repository on GitHub.
-2. Clone your fork to your local machine.
-3. Create a new branch for your changes.
+1. Crea una bifurcación del repositorio en GitHub.
+2. Clona tu rama en tu máquina local.
+3. Crea una nueva rama para tus cambios.
 
 ```bash
 git checkout -b my-feature-branch
 ```
 
-4. Make your changes and commit them with clear messages. We follow [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/), your PR will not be accepted if your commit messages do not follow this convention.
+4. Haz tus cambios y confírmalos con mensajes claros. Seguimos los [commits convencionales](https://www.conventionalcommits.org/es/v1.0.0/), Tu PR no será aceptada si los mensajes de tus commits no siguen esta convención.
 
 ```bash
-git commit -m "Add feature X to documentation"
+git commit -m "Añade la funcionalidad X a la documentación".
 ```
 
-5. Push your changes to your fork.
+5. Aplicar los cambios a tu rama
 
 ```bash
 git push origin my-feature-branch
 ```
 
-6. Open a Pull Request on the original repository, describing your changes and why they should be merged.
+6. Abre un Pull request en el repositorio original, describe los cambios y el porqué debería fusionarse.
diff --git a/content/docs/es-ES/contributing/pr-guidelines.mdx b/content/docs/es-ES/contributing/pr-guidelines.mdx
index 7a251032..e64ff3f1 100644
--- a/content/docs/es-ES/contributing/pr-guidelines.mdx
+++ b/content/docs/es-ES/contributing/pr-guidelines.mdx
@@ -1,39 +1,39 @@
 ---
-title: PR Guidelines
-description: Guidelines that reviewers and contributors should follow when submitting and reviewing pull requests.
+title: Guías para Pull Request.
+description: Pautas que los revisores y colaboradores deben seguir al enviar y revisar los Pull Request.
 ---
 
-# Pull Request Guidelines
+# Guías para los Pull Request.
 
-To ensure a smooth and efficient review process, both contributors and reviewers should adhere to the following guidelines when submitting and reviewing pull requests (PRs).
+Para garantizar un proceso de revisión fluido y eficiente, tanto los colaboradores como los revisores deben seguir las siguientes directrices al enviar y revisar solicitudes de incorporación de cambios (PRs).
 
-## For Contributors
+## Para los contribuidores.
 
-1. **Descriptive Titles and Descriptions**
-   - Use clear and concise titles that summarize the changes.
-   - Provide detailed descriptions of what the PR does, why the changes are necessary, and any relevant context.
-2. **Link to Issues**
-   - In your PR title, add `GH-ISSUE-NUMBER` to link the PR to the relevant issue. This is required for all PRs.
-3. **Small, Focused Changes**
-   - Aim to keep PRs small and focused on a single issue or feature. This makes it easier for reviewers to understand and provide feedback.
-4. **Code Quality**
-   - Ensure your code follows the project's coding standards and best practices.
-   - Include comments where necessary to explain complex logic.
-5. **Testing**
-   - Test your changes thoroughly before submitting the PR.
-   - If applicable, include unit tests or integration tests to verify your changes.
-6. **Documentation**
-   - Update or add documentation as needed to reflect your changes.
-7. **Commit Messages**
-   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
-8. **Check for Conflicts**
-   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+1. **Títulos y descripciones detalladas.**
+   - Utiliza títulos claros y concisos que resuman los cambios.
+   - Provee descripciones detalladas de lo que hace el PR, El porqué los cambios son necesarios y algún contexto relevante.
+2. **Enlazar Incidencias**
+   - En el título de tu PR, añade \`GH-ISSUE-NUMBER para vincular el PR con el problema correspondiente. Esto es obligatorio para todas las solicitudes de incorporación de cambios.
+3. **Cambios pequeños enfocados**
+   - Procura que los PR sean pequeños y estén centrados en un único problema o funcionalidad. Esto facilita que los revisores entiendan y puedan dar feedback.
+4. **Calidad del Código**
+   - Asegúrate de que tu código siga los estándares de codificación y buenas prácticas del proyecto.
+   - Incluye comentarios cuando sea necesario para explicar lógica compleja.
+5. **Prueba**
+   - Prueba tus cambios a fondo antes de enviar el PR.
+   - Si aplica, incluye pruebas unitarias o pruebas de integración para verificar tus cambios.
+6. **Documentación**
+   - Actualiza o añade la documentación necesaria para reflejar tus cambios.
+7. **Mensajes de confirmación**
+   - Utiliza mensajes de confirmación claros y descriptivos que sigan el formato de [confirmaciones convencionales](https://www.conventionalcommits.org/es/v1.0.0/).
+8. **Comprobar Conflictos**
+   - Antes de enviar tu solicitud de incorporación de cambios, asegúrate de que tu rama esté actualizada con respecto a la rama base para minimizar conflictos de fusión.
 
-## For Reviewers
+## Para Revisores
 
-- You are supposed to review PRs thoroughly, and request changes if needed.
-- Provide constructive feedback and suggestions for improvement.
-- Verify that the changes meet the project's coding standards and best practices.
-- Deploy the PR using the dokploy integration to ensure the changes work as expected.
-- Ensure that documentation is updated as necessary.
-- Approve the PR only when you are satisfied with the changes and all checks have passed.
+- Debes revisar las solicitudes de incorporación de cambios de forma exhaustiva y solicitar cambios si es necesario.
+- Proporcionar comentarios constructivos y sugerencias de mejora.
+- Verifica que los cambios cumplen los estándares de codificación y mejores prácticas del proyecto.
+- Despliega el PR usando la integración de dokploy para asegurarte de que los cambios funcionan como se espera.
+- Asegúrate de que la documentación se actualice cuando sea necesario.
+- Aprueba las solicitudes de incorporación de cambios solo cuando estés satisfecho con los cambios y todas las comprobaciones se hayan superado.
diff --git a/content/docs/es-ES/contributing/writing-guides.mdx b/content/docs/es-ES/contributing/writing-guides.mdx
index 55c52ade..33a52343 100644
--- a/content/docs/es-ES/contributing/writing-guides.mdx
+++ b/content/docs/es-ES/contributing/writing-guides.mdx
@@ -1,86 +1,86 @@
 ---
-title: Writing Guides
+title: Guías de escritura
 ---
 
-## Creating a guide file
+## Creación de un archivo de guía
 
-To start writing a guide, you need to create a file with extension `.mdx`. You need to create this file inside the `/content/docs/en` directory, now it depends in which section you want to make the guide, so you can decide which folder you should put it in after that.
+Para empezar a escribir una guía, necesitas crear un archivo con la extensión `.mdx`. Necesitas crear este archivo dentro del directorio `/content/docs/en` a partir de ahí, dependerá de la sección en la que quieras crear la guía, por lo que podrás decidir en qué carpeta debes colocarla.
 
-Suppose I want to make a java basics guide, I'd put it in `/content/docs/en/guides/java-basics`. You'll have to do some digging to find out where you want to place it.
+Supongamos que quiero crear una guía de fundamentos de Java, la colocaría en `/content/docs/en/guides/java-basics.` Tendrás que investigar un poco para decidir dónde quieres colocarla.
 
 <Callout>
-  If there's already a guide in the section you want to write about, you can just press on the "Edit On GitHub" button on our website and it'll take you to the folder, now you can write in the same folder to have your guide appear in the same section.
+  Si ya existe una guía en la sección sobre la que quieres escribir, puedes pulsar simplemente el botón "Editar en GitHub" en nuestro sitio web y este te llevará a la carpeta correspondiente; a partir de ahí, puedes escribir en esa misma carpeta para que tu guía aparezca en la misma sección.
 </Callout>
 
 ## Frontmatter
 
-Frontmatter is the metadata of your guide, it tells our website how to display your guide. This needs to be at the very top of the file, which starts with `---` and ends with `---`.
+El Frontmatter es el metadato de tu guía; indica a nuestro sitio web cómo debe mostrarse la guía. Esto debe ir en la parte superior del archivo, que empieza con `---` y termina con `---`.
 
-Here's an example:
+Aquí un ejemplo:
 
 ```mdx
 ---
-title: "Java Basics"
-description: "Learn the basics of Java programming."
+title: "Básicos de Java"
+description: "Aprende lo básico para programar con Java"
 authors:
-    - name: "Your Name"
-      url: "https://yourwebsite.com"
+    - name: "Tu nombre"
+      url: "https://tupaginaweb.com"
 ---
 ```
 
-Now as you can see, it's pretty self explanatory, you just need to fill in the details for your specific guide. If you don't have a URL you want to link yourself to, just don't write that whole line. Additionally, the authors section is optional, so if you don't want to add it, you can just leave it out although we encourage you to do so and credit yourself.
+Como puedes ver, es bastante autoexplicativo, solo tienes que rellenar los detalles correspondientes a tu guía específica. Si no tienes una URL que quieras enlazar, simplemente no escribas esa línea completa. Adicionalmente, la sección de autores es opcional, así que si no quieres añadirla, puedes omitirla, aunque te animamos a hacerlo y darte crédito.
 
-The indentation in the frontmatter is important, so make sure to keep it consistent with the example.
+La identación en el frontmatter es importante, así que asegúrate de mantenerla consistente con el ejemplo.
 
-## Content Structure
+## Estructura del contenido
 
-You should structure the content of your guide in a clear and organized manner. Here are some tips on how to do that:
+Debes estructurar el contenido de tu guía de forma clara y organizada. Aquí tienes algunos consejos para hacerlo:
 
-- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
-- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
-- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
-- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
-- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+- **Introducción:** Empieza con una visión general del tema y lo que el lector puede esperar aprender.
+- **Prerequisitos:** Enumera los requisitos previos o conocimientos necesarios que el lector debería tener antes de empezar la guía.
+- **Instrucciones Paso-a-Paso:** Divide el contenido en pasos claros y accionables. Usa encabezados y sub encabezados para organizar la información.
+- **Ejemplos de código:** Incluye fragmentos de código para ilustrar los puntos clave. Asegúrate de explicar cada ejemplo a fondo.
+- **Conclusión:** Resume los puntos principales y anima al lector a profundizar más o a poner en práctica lo que aprendió.
 
-Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+Si estás escribiendo una sección muy grande, deberías dividirla en varias páginas para que al lector le resulte más fácil asimilar la información. ¡Nadie quiere leerse un muro enorme de texto de una sola vez!
 
-When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+Cuando escribimos guías, también deberíamos pensar en cómo lo asumirá la gente, muchas personas prefieren ojear el contenido en lugar de leerlo en detalle. Por eso es mejor dividir la información en varias páginas, de modo que al lector le parezca una cantidad menor de contenido. Además, considera usar viñetas, listas enumeradas y otras técnicas de formato para que el contenido sea más fácil de escanear.
 
-## Formatting
+## Formato
 
-We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+Usamos [Markdown](https://www.markdownguide.org/) para formatear nuestras guías. Aquí tienes algunos puntos clave a tener en cuenta:
 
-- Use headings (`#`, `##`, `###`) to organize your content.
-- Use bullet points and numbered lists for clarity.
+- Usa encabezados (`#`, `##`, `###`) para organizar tu contenido.
+- Usa viñetas y listas enumeradas para mayor claridad.
 - Use code blocks (\`\`\`) for code snippets.
-- Use links to reference other guides or external resources.
+- Usa links de referencia a otras guías o recursos externos.
 
-This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+Este es el mismo tipo de formato que verás en la mayoría de sitios web de documentación y también en plataformas de redes sociales como Discord.
 
-You can also make a Callout to highlight important information or tips. Use the following syntax:
+También puedes usar un Callout para resaltar información importante o consejos. Usa la siguiente sintaxis:
 
 ```mdx
 <Callout>
-    This is a callout message.
+    Esto es un mensaje Callout.
 </Callout>
 ```
 
 <Callout>
-  This is a callout message.
+  Esto es un mensaje Callout
 </Callout>
 
-You can change the color of the callout by adding a `type` attribute. For example:
+Puedes cambiar el color del callout añadiendo un atributo `type` Por ejemplo:
 
 ```mdx
 <Callout type="info">
-    This is an info callout.
+    Esto es información del callout.
 </Callout>
 ```
 
-Available types are: `info`, `warning`, `error`, and `success`.
+Tipos disponibles: `info`, `warning`, `error`, y `success`
 
-## Conclusion
+## Conclusión
 
-That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+¡Eso es todo! Ahora eres un master escribiendo guías. Solo recuerda: no hace falta que tu inglés sea perfecto, escribe la guía tal y como le explicarías el tema a alguien y no dudes en pedir feedback o ayuda si lo necesitas.
 
-Happy writing!
+¡Feliz escritura!
diff --git a/content/docs/es-ES/established-information/gameplay/creative.mdx b/content/docs/es-ES/established-information/gameplay/creative.mdx
index c2c4e4b4..ebb058da 100644
--- a/content/docs/es-ES/established-information/gameplay/creative.mdx
+++ b/content/docs/es-ES/established-information/gameplay/creative.mdx
@@ -1,158 +1,158 @@
 ---
-title: Creative
-description: Information regarding the creative mode in Hytale.
+title: Creativo
+description: Información acerca del modo creativo en Hytale.
 ---
 
-# Creative Mode
+# Modo Creativo
 
-Creative mode in Hytale is a sandbox mode that allows players to edit the world freely.
+El modo creativo en Hytale es un modo sandbox que permite a los jugadores editar el mundo libremente.
 
-## World Editing Tools
+## Herramientas de Edición de Mundo
 
-Creative mode includes a variety of tools to help players edit the world. It includes undo functionality for edits.
+El modo creativo incluye una variedad de herramientas para ayudar a los jugadores a editar el mundo. Incluye la funcionalidad de deshacer para ediciones.
 
-Note that the below sections were unnamed in the video demo of the tools.
+Tenga en cuenta que las secciones de abajo no fueron nombradas en la demostración de vídeo de las herramientas.
 
 ---
 
-### Laser Pointer
+### Puntero láser
 
-Displays a ray from the player's camera in the direction the player is looking.
+Muestra un rayo de la cámara del jugador en la dirección que el jugador está mirando.
 
-#### Settings
+#### Configuración
 
-- Duration (Integer Slider): Description unknown as of December 2025.
-- Laser Color (Hex Color Code): Description unknown as of December 2025.
+- Duración (deslizador de enteros): Descripción desconocida a partir de diciembre de 2025.
+- Color del láser (código de color hexadecimal): descripción desconocida a diciembre de 2025.
 
-### Sculpt Brush Tool
+### Herramienta de Pincel de Esculpir
 
-Allows the user to raise and lower the terrain to more accurately sculpt and blend shapes. Supports most features of the Paint Brush.
+Permite al usuario subir y bajar el terreno a formas más precisas de esculpido y mezclado. Soporta la mayoría de las características del Pincel
 
-### Line Brush Tool
+### Herramienta de Pincel de Línea
 
-Unknown as of December 2025.
+Desconocido en diciembre de 2025.
 
-### Selection Tool
+### Herramienta de selección
 
-Allows the user to select and edit regions of the world by transforming selections of blocks or a prefab via position, rotation, and extrusion.
+Permite al usuario seleccionar y editar regiones del mundo transformando selecciones de bloques o un prefabricado mediante posición, rotación y extrusión.
 
-#### Settings
+#### Configuración
 
-- Mode (Combo Box: Set, Wall, Fill, Replace): Description unknown as of December 2025.
-- Material (Integer Slider): Description unknown as of December 2025.
-- Weight (Integer Slider): Description unknown as of December 2025.
-- Pitch (Integer): Description unknown as of December 2025.
+- Modo (Combo Box: Colocar, Pared, Rellenar, Reemplazar): Descripción desconocida a partir de diciembre de 2025.
+- Material (deslizador entero): Descripción desconocida a partir de diciembre de 2025.
+- Peso (deslizador entero): Descripción desconocida a partir de diciembre de 2025
+- Tono (entero): Descripción desconocida a diciembre de 2025.
 
-### Ruler
+### Regla
 
-Allows the user to measure distances between multiple points in 3D space, with support for multiple measurement lines and editing of measured points.
+Permite medir distancias entre múltiples puntos en espacio 3D, con soporte para múltiples líneas de medición y edición de puntos medidos.
 
-### Layer Brush Tool
+### Pincel de Capas
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
-### Paste Tool
+### Herramienta de Pegado
 
-Allows the user to paste a copied selection of blocks or a prefab at the point at which the player is looking. The paste is relative to the selection's anchor point. If the selection is a prefab, the anchor point may be set in the Prefab Editor. It is unknown if the selection's anchor may be set otherwise.
+Permite al usuario pegar una selección de bloques o un prefabricado copiados en el punto al que el jugador está mirando. El pegado se realiza tomando como referencia el punto de anclaje de la selección Si la selección es un prefabricado, el punto de anclaje puede configurarse en el Editor de Prefabricados. Se desconoce si el ancla de la selección se puede establecer de otra manera.
 
-### Flood Brush Tool
+### Herramienta de Relleno
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
-### Paint Brush Tool
+### Herramienta de Pincel
 
-Brushes are used to make large changes to the world from far away.
+Los Pinceles se utilizan para hacer grandes cambios en el mundo desde lejos.
 
-#### General Abilities
+#### Habilidades generales
 
-- Place Shapes and Prefabs
-- Replace Blocks
-- Create Axis Locks and Masks
+- Colocar formas y prefabricados
+- Reemplazar Bloques
+- Crear bloqueos de ejes y máscaras
 
-#### Settings
+#### Configuración
 
 - Material
-- Width (Integer Slider): Description unknown as of December 2025.
-- Height (Integer Slider): Description unknown as of December 2025.
-- Shape (Combo Box: Cube, Sphere, Cylinder, Cone, Inverted Cone, Pyramid, Inverted Pyramid, Cuboid Grid): Description unknown as of December 2025.
-- Origin (Combo Box: Center, Bottom, Top): Description unknown as of December 2025.
-- Mirror Axis (Combo Box: None, Unknown other options): Description unknown as of December 2025.
-- Wall Thickness (Integer Slider): Description unknown as of December 2025.
-- Density (Integer Slider): Description unknown as of December 2025.
+- Duración (deslizador de enteros): Descripción desconocida a partir de diciembre de 2025.
+- Altura (deslizador de enteros): Descripción desconocida a partir de diciembre de 2025.
+- Forma (Caja combinada: Cubo, Esfera, Cilindro, Cono, Cono Invertido, Pirámide, Pirámide Invertida, Rejilla de Cuboide): Descripción desconocida hasta diciembre de 2025.
+- Origen (Caja combinada: Centro, Inferior, Superior): Descripción desconocida hasta diciembre de 2025.
+- Eje de Espejo (Caja combinada: Ninguno, otras opciones desconocidas): Descripción desconocida hasta diciembre de 2025.
+- Grosor de Pared (Deslizador de enteros): Descripción desconocida hasta diciembre de 2025.
+- Densidad (Deslizador de enteros): Descripción desconocida hasta diciembre de 2025.
 
 #### Presets:
 
-- Boulder: Creates a boulder at the point at which the player is looking.
-- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
-- Rubble: Generate rubble at the point at which the player is looking.
-- Tentacle: TBD
-- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
-- Hot Springs: TBD
-- Ruins: Generates a ruin at the point at which the player is looking.
-- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
-- Grass: TBD
-- Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
-- Ruins: TBD
+- Roca: Crea una roca en el punto en el que el jugador está mirando.
+- Ruta de hierba: Transforma el terreno en un camino de hierba en el punto en el que el jugador está mirando.
+- Escombros: Genera escombros en el punto hacia el que el jugador está mirando.
+- Tentáculo: Por determinar
+- Fragmentos de lava: Transforma el terreno en una grieta de lava en el punto en el que el jugador está mirando.
+- Termas: Por determinar
+- Ruinas: Genera una ruina en el punto hacia donde mira el jugador.
+- Ruinas con techo: Genera una ruina con techo en el punto hacia donde mira el jugador.
+- Césped: Por determinar
+- Montaña: Coloca trozos consecutivos de terreno para formar una montaña en el punto hacia donde mira el jugador.
+- Ruinas: Por determinar
 
 ---
 
-### Entity Grabber Tool
+### Manipulador de entidades
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
-### Noise Brush Tool
+### Pincel de Ruido
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
-### Scatter Brush Tool
+### Pincel de Dispersión
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
-### Extrude Brush Tool
+### Pincel de Extrusión
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
-### Prefab Selector Tool
+### Selector de Prefabricados
 
-Allows the user to select a prefab when inside the Prefab Editor. May be used with the copy command.
+Permite al usuario seleccionar un prefabricado dentro del Editor de Prefabricados Se puede utilizar con el comando «copiar».
 
-### Smooth Brush Tool
+### Pincel de Suavizado
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
-### Hitbox Tool
+### Herramienta de colisión
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
-### Set Anchor Tool
+### Fijar Anclaje
 
-Allows the user to set an anchor point for a prefab when inside the Prefab Editor.
+Permite al usuario establecer un punto de anclaje para un prefabricado cuando está dentro del Editor de prefabricados.
 
-### Tint Brush Tool
+### Pincel de Tinte
 
-Unknown as of December 2025.
+Desconocido a diciembre de 2025.
 
 ---
 
-## Creative Mode Quick Settings
-
-Note that these are WIP and subject to change. **Not all settings and functionality are currently known**.
-
-- Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
-- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
-- Brush Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
-- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
-- Display Legend (Toggle): Description unknown as of December 2025.
-- Show Tool Notifications (Toggle): Description unknown as of December 2025.
-- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
-- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
-- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
-- Flight Intertia (Integer Slider): Description unknown as of December 2025.
-- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
-- No Clip (Toggle): Description unknown as of December 2025.
-- Air Placement (Toggle): Description unknown as of December 2025.
+## Ajustes rápidos del modo creativo
+
+Tenga en cuenta que estos son Trabajos en Proceso (WIP) y están sujetos a cambios. **No todos los ajustes y funciones son conocidos actualmente**.
+
+- Alcance de la Herramienta (Deslizador de enteros): Descripción desconocida hasta diciembre de 2025.
+- Retraso Mínimo de la Herramienta (Deslizador de enteros): Descripción desconocida hasta diciembre de 2025.
+- Opacidad del Pincel (Deslizador de enteros): Descripción desconocida hasta diciembre de 2025.
+- Opacidad de la Selección (Deslizador de enteros): Descripción desconocida hasta diciembre de 2025.
+- Opacidad del Panel de Selección (Deslizador de enteros): Descripción desconocida hasta diciembre de 2025.
+- Habilitar Renderizado de Forma del Pincel (Interruptor): Descripción desconocida hasta diciembre de 2025.
+- Mostrar Leyenda (Interruptor): Descripción desconocida hasta diciembre de 2025.
+- Mostrar notificaciones de herramientas (activar/desactivar): descripción desconocida a diciembre de 2025.
+- Puntero láser por defecto (código de color hexadecimal): descripción desconocida a diciembre de 2025.
+- Habilitar espaciamiento del pincel (Alternar): Descripción desconocida en diciembre de 2025.
+- ¿Espaciado entre pinceles? (Deslizador de enteros): Descripción desconocida en diciembre de 2025.
+- Inercia de Vuelo (Deslizador entero): Descripción desconocida en diciembre de 2025.
+- Modo de Vuelo (Caja combinada: flotar, direccional): Descripción desconocida en diciembre de 2025.
+- No Clip (Alternar): Descripción desconocida en diciembre de 2025.
+- Colocación en el Aire (Alternar): Descripción desconocida en diciembre de 2025
 
 ## Content Creation Tools
 
diff --git a/content/docs/es-ES/guides/ecs/entity-component-system.mdx b/content/docs/es-ES/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/es-ES/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/es-ES/guides/ecs/example-ecs-plugin.mdx b/content/docs/es-ES/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/es-ES/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/es-ES/guides/ecs/hytale-ecs-theory.mdx b/content/docs/es-ES/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/es-ES/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/es-ES/guides/ecs/systems.mdx b/content/docs/es-ES/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/es-ES/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/es-ES/guides/java-basics/00-introduction.mdx b/content/docs/es-ES/guides/java-basics/00-introduction.mdx
index f85a3848..6f9e975f 100644
--- a/content/docs/es-ES/guides/java-basics/00-introduction.mdx
+++ b/content/docs/es-ES/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Antes de meternos en la programación, necesitarás instalar elementos esenciale
 
 ### Kit de desarrollo de Java (JDK)
 
-Descárgate e instala el JDK versión 25 o superior desde [la página oficial de Oracle](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) o usa una alternativa de código abierto como [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Entorno de Desarrollo Integrado (IDE)
+### Integrated Development Environment (IDE)
 
 Un IDE es un programa que proporciona a los programadores herramientas completas para el desarrollo de software. Entre las opciones populares para Java se incluyen:
 
diff --git a/content/docs/es-ES/guides/java-basics/06-methods-functions.mdx b/content/docs/es-ES/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/es-ES/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/es-ES/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/es-ES/guides/plugin/block-components.mdx b/content/docs/es-ES/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/es-ES/guides/plugin/browsing-serverjar.mdx b/content/docs/es-ES/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/es-ES/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/es-ES/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/es-ES/guides/plugin/build-and-test.mdx b/content/docs/es-ES/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/es-ES/guides/plugin/chat-formatting.mdx b/content/docs/es-ES/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/es-ES/guides/plugin/chat-formatting.mdx
+++ b/content/docs/es-ES/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/es-ES/guides/plugin/client-inputs-reference.mdx b/content/docs/es-ES/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/es-ES/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/es-ES/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/es-ES/guides/plugin/creating-block.mdx b/content/docs/es-ES/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/es-ES/guides/plugin/creating-block.mdx
+++ b/content/docs/es-ES/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/es-ES/guides/plugin/creating-commands.mdx b/content/docs/es-ES/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/es-ES/guides/plugin/creating-commands.mdx
+++ b/content/docs/es-ES/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/es-ES/guides/plugin/creating-configuration-file.mdx b/content/docs/es-ES/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/es-ES/guides/plugin/creating-events.mdx b/content/docs/es-ES/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/es-ES/guides/plugin/creating-events.mdx
+++ b/content/docs/es-ES/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/es-ES/guides/plugin/customizing-camera-controls.mdx b/content/docs/es-ES/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/es-ES/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/es-ES/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/es-ES/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/es-ES/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/es-ES/guides/plugin/instances.mdx b/content/docs/es-ES/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/es-ES/guides/plugin/inventory-management.mdx b/content/docs/es-ES/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/es-ES/guides/plugin/inventory-management.mdx
+++ b/content/docs/es-ES/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/es-ES/guides/plugin/item-interaction.mdx b/content/docs/es-ES/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/es-ES/guides/plugin/listening-to-packets.mdx b/content/docs/es-ES/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/es-ES/guides/plugin/logging.mdx b/content/docs/es-ES/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/es-ES/guides/plugin/player-death-event.mdx b/content/docs/es-ES/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/es-ES/guides/plugin/player-input-guide.mdx b/content/docs/es-ES/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/es-ES/guides/plugin/player-input-guide.mdx
+++ b/content/docs/es-ES/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/es-ES/guides/plugin/player-stats.mdx b/content/docs/es-ES/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/es-ES/guides/plugin/setting-up-env.mdx b/content/docs/es-ES/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/es-ES/guides/plugin/setting-up-env.mdx
+++ b/content/docs/es-ES/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/es-ES/guides/plugin/spawning-entities.mdx b/content/docs/es-ES/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/es-ES/guides/plugin/spawning-entities.mdx
+++ b/content/docs/es-ES/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/es-ES/guides/plugin/spawning-npcs.mdx b/content/docs/es-ES/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/es-ES/guides/plugin/store-persistant-data.mdx b/content/docs/es-ES/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/es-ES/guides/plugin/teleporting-players.mdx b/content/docs/es-ES/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/es-ES/guides/plugin/teleporting-players.mdx
+++ b/content/docs/es-ES/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/es-ES/guides/plugin/text-hologram.mdx b/content/docs/es-ES/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/es-ES/guides/plugin/ui.mdx b/content/docs/es-ES/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/es-ES/guides/plugin/world-gen.mdx b/content/docs/es-ES/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/es-ES/guides/plugin/world-gen.mdx
+++ b/content/docs/es-ES/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/es-ES/guides/prefabs.mdx b/content/docs/es-ES/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/es-ES/guides/prefabs.mdx
+++ b/content/docs/es-ES/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/es-ES/official-documentation/npc-doc.mdx b/content/docs/es-ES/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/es-ES/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/es-ES/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/es-ES/publishing/builtbybit.mdx b/content/docs/es-ES/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/es-ES/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/es-ES/publishing/index.mdx b/content/docs/es-ES/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/es-ES/publishing/index.mdx
+++ b/content/docs/es-ES/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/fr-FR/contributing/index.mdx b/content/docs/fr-FR/contributing/index.mdx
index ac05eb21..64c76146 100644
--- a/content/docs/fr-FR/contributing/index.mdx
+++ b/content/docs/fr-FR/contributing/index.mdx
@@ -1,12 +1,12 @@
 ---
-title: Contributing
+title: Contribuer
 ---
 
-# Contributing to HytaleModding
+# Contribuer à HytaleModding
 
-We welcome contributions from the community to help improve and expand the HytaleModding documentation. Whether you're fixing typos, adding new tutorials, or providing code examples, your contributions are valuable!
+Nous accueillons les contributions de la communauté pour aider à améliorer et étendre la documentation d'HytaleModding. Que vous corrigiez des typos, ajoutiez des nouveaux tutoriels, ou fournissiez des exemples de code, votre contribution est précieuse !
 
-## How to Contribute
+## Comment contribuer
 
 ### Reporting Issues
 
diff --git a/content/docs/fr-FR/guides/ecs/entity-component-system.mdx b/content/docs/fr-FR/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/fr-FR/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/fr-FR/guides/ecs/example-ecs-plugin.mdx b/content/docs/fr-FR/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/fr-FR/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/fr-FR/guides/ecs/hytale-ecs-theory.mdx b/content/docs/fr-FR/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/fr-FR/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/fr-FR/guides/ecs/systems.mdx b/content/docs/fr-FR/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/fr-FR/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/fr-FR/guides/java-basics/00-introduction.mdx b/content/docs/fr-FR/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/fr-FR/guides/java-basics/00-introduction.mdx
+++ b/content/docs/fr-FR/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/fr-FR/guides/java-basics/06-methods-functions.mdx b/content/docs/fr-FR/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/fr-FR/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/fr-FR/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/fr-FR/guides/plugin/block-components.mdx b/content/docs/fr-FR/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/fr-FR/guides/plugin/browsing-serverjar.mdx b/content/docs/fr-FR/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/fr-FR/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/fr-FR/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/fr-FR/guides/plugin/build-and-test.mdx b/content/docs/fr-FR/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/fr-FR/guides/plugin/chat-formatting.mdx b/content/docs/fr-FR/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/fr-FR/guides/plugin/chat-formatting.mdx
+++ b/content/docs/fr-FR/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/fr-FR/guides/plugin/client-inputs-reference.mdx b/content/docs/fr-FR/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/fr-FR/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/fr-FR/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/fr-FR/guides/plugin/creating-block.mdx b/content/docs/fr-FR/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/fr-FR/guides/plugin/creating-block.mdx
+++ b/content/docs/fr-FR/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/fr-FR/guides/plugin/creating-commands.mdx b/content/docs/fr-FR/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/fr-FR/guides/plugin/creating-commands.mdx
+++ b/content/docs/fr-FR/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/fr-FR/guides/plugin/creating-configuration-file.mdx b/content/docs/fr-FR/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/fr-FR/guides/plugin/creating-events.mdx b/content/docs/fr-FR/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/fr-FR/guides/plugin/creating-events.mdx
+++ b/content/docs/fr-FR/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/fr-FR/guides/plugin/customizing-camera-controls.mdx b/content/docs/fr-FR/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/fr-FR/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/fr-FR/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/fr-FR/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/fr-FR/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/fr-FR/guides/plugin/instances.mdx b/content/docs/fr-FR/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/fr-FR/guides/plugin/inventory-management.mdx b/content/docs/fr-FR/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/fr-FR/guides/plugin/inventory-management.mdx
+++ b/content/docs/fr-FR/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/fr-FR/guides/plugin/item-interaction.mdx b/content/docs/fr-FR/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/fr-FR/guides/plugin/listening-to-packets.mdx b/content/docs/fr-FR/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/fr-FR/guides/plugin/logging.mdx b/content/docs/fr-FR/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/fr-FR/guides/plugin/player-death-event.mdx b/content/docs/fr-FR/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/fr-FR/guides/plugin/player-input-guide.mdx b/content/docs/fr-FR/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/fr-FR/guides/plugin/player-input-guide.mdx
+++ b/content/docs/fr-FR/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/fr-FR/guides/plugin/player-stats.mdx b/content/docs/fr-FR/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/fr-FR/guides/plugin/setting-up-env.mdx b/content/docs/fr-FR/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/fr-FR/guides/plugin/setting-up-env.mdx
+++ b/content/docs/fr-FR/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/fr-FR/guides/plugin/spawning-entities.mdx b/content/docs/fr-FR/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/fr-FR/guides/plugin/spawning-entities.mdx
+++ b/content/docs/fr-FR/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/fr-FR/guides/plugin/spawning-npcs.mdx b/content/docs/fr-FR/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/fr-FR/guides/plugin/store-persistant-data.mdx b/content/docs/fr-FR/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/fr-FR/guides/plugin/teleporting-players.mdx b/content/docs/fr-FR/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/fr-FR/guides/plugin/teleporting-players.mdx
+++ b/content/docs/fr-FR/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/fr-FR/guides/plugin/text-hologram.mdx b/content/docs/fr-FR/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/fr-FR/guides/plugin/ui.mdx b/content/docs/fr-FR/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/fr-FR/guides/plugin/world-gen.mdx b/content/docs/fr-FR/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/fr-FR/guides/plugin/world-gen.mdx
+++ b/content/docs/fr-FR/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/fr-FR/guides/prefabs.mdx b/content/docs/fr-FR/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/fr-FR/guides/prefabs.mdx
+++ b/content/docs/fr-FR/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/fr-FR/official-documentation/npc-doc.mdx b/content/docs/fr-FR/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/fr-FR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/fr-FR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/fr-FR/publishing/builtbybit.mdx b/content/docs/fr-FR/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/fr-FR/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/fr-FR/publishing/index.mdx b/content/docs/fr-FR/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/fr-FR/publishing/index.mdx
+++ b/content/docs/fr-FR/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/hi-IN/guides/ecs/entity-component-system.mdx b/content/docs/hi-IN/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/hi-IN/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/hi-IN/guides/ecs/example-ecs-plugin.mdx b/content/docs/hi-IN/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/hi-IN/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/hi-IN/guides/ecs/hytale-ecs-theory.mdx b/content/docs/hi-IN/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/hi-IN/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/hi-IN/guides/ecs/systems.mdx b/content/docs/hi-IN/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/hi-IN/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/hi-IN/guides/java-basics/00-introduction.mdx b/content/docs/hi-IN/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/hi-IN/guides/java-basics/00-introduction.mdx
+++ b/content/docs/hi-IN/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/hi-IN/guides/java-basics/06-methods-functions.mdx b/content/docs/hi-IN/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/hi-IN/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/hi-IN/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/hi-IN/guides/plugin/block-components.mdx b/content/docs/hi-IN/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/hi-IN/guides/plugin/browsing-serverjar.mdx b/content/docs/hi-IN/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/hi-IN/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/hi-IN/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/hi-IN/guides/plugin/build-and-test.mdx b/content/docs/hi-IN/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/hi-IN/guides/plugin/chat-formatting.mdx b/content/docs/hi-IN/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/hi-IN/guides/plugin/chat-formatting.mdx
+++ b/content/docs/hi-IN/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/hi-IN/guides/plugin/client-inputs-reference.mdx b/content/docs/hi-IN/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/hi-IN/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/hi-IN/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/hi-IN/guides/plugin/creating-block.mdx b/content/docs/hi-IN/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/hi-IN/guides/plugin/creating-block.mdx
+++ b/content/docs/hi-IN/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/hi-IN/guides/plugin/creating-commands.mdx b/content/docs/hi-IN/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/hi-IN/guides/plugin/creating-commands.mdx
+++ b/content/docs/hi-IN/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/hi-IN/guides/plugin/creating-configuration-file.mdx b/content/docs/hi-IN/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/hi-IN/guides/plugin/creating-events.mdx b/content/docs/hi-IN/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/hi-IN/guides/plugin/creating-events.mdx
+++ b/content/docs/hi-IN/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/hi-IN/guides/plugin/customizing-camera-controls.mdx b/content/docs/hi-IN/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/hi-IN/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/hi-IN/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/hi-IN/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/hi-IN/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/hi-IN/guides/plugin/instances.mdx b/content/docs/hi-IN/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/hi-IN/guides/plugin/inventory-management.mdx b/content/docs/hi-IN/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/hi-IN/guides/plugin/inventory-management.mdx
+++ b/content/docs/hi-IN/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/hi-IN/guides/plugin/item-interaction.mdx b/content/docs/hi-IN/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/hi-IN/guides/plugin/listening-to-packets.mdx b/content/docs/hi-IN/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/hi-IN/guides/plugin/logging.mdx b/content/docs/hi-IN/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/hi-IN/guides/plugin/player-death-event.mdx b/content/docs/hi-IN/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/hi-IN/guides/plugin/player-input-guide.mdx b/content/docs/hi-IN/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/hi-IN/guides/plugin/player-input-guide.mdx
+++ b/content/docs/hi-IN/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/hi-IN/guides/plugin/player-stats.mdx b/content/docs/hi-IN/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/hi-IN/guides/plugin/setting-up-env.mdx b/content/docs/hi-IN/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/hi-IN/guides/plugin/setting-up-env.mdx
+++ b/content/docs/hi-IN/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/hi-IN/guides/plugin/spawning-entities.mdx b/content/docs/hi-IN/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/hi-IN/guides/plugin/spawning-entities.mdx
+++ b/content/docs/hi-IN/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/hi-IN/guides/plugin/spawning-npcs.mdx b/content/docs/hi-IN/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/hi-IN/guides/plugin/store-persistant-data.mdx b/content/docs/hi-IN/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/hi-IN/guides/plugin/teleporting-players.mdx b/content/docs/hi-IN/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/hi-IN/guides/plugin/teleporting-players.mdx
+++ b/content/docs/hi-IN/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/hi-IN/guides/plugin/text-hologram.mdx b/content/docs/hi-IN/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/hi-IN/guides/plugin/ui.mdx b/content/docs/hi-IN/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/hi-IN/guides/plugin/world-gen.mdx b/content/docs/hi-IN/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/hi-IN/guides/plugin/world-gen.mdx
+++ b/content/docs/hi-IN/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/hi-IN/guides/prefabs.mdx b/content/docs/hi-IN/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/hi-IN/guides/prefabs.mdx
+++ b/content/docs/hi-IN/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/hi-IN/official-documentation/npc-doc.mdx b/content/docs/hi-IN/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/hi-IN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/hi-IN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/hi-IN/publishing/builtbybit.mdx b/content/docs/hi-IN/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/hi-IN/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/hi-IN/publishing/index.mdx b/content/docs/hi-IN/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/hi-IN/publishing/index.mdx
+++ b/content/docs/hi-IN/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/hu-HU/guides/ecs/entity-component-system.mdx b/content/docs/hu-HU/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/hu-HU/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/hu-HU/guides/ecs/example-ecs-plugin.mdx b/content/docs/hu-HU/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/hu-HU/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/hu-HU/guides/ecs/hytale-ecs-theory.mdx b/content/docs/hu-HU/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/hu-HU/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/hu-HU/guides/ecs/systems.mdx b/content/docs/hu-HU/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/hu-HU/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/hu-HU/guides/java-basics/00-introduction.mdx b/content/docs/hu-HU/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/hu-HU/guides/java-basics/00-introduction.mdx
+++ b/content/docs/hu-HU/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/hu-HU/guides/java-basics/06-methods-functions.mdx b/content/docs/hu-HU/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/hu-HU/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/hu-HU/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/hu-HU/guides/plugin/block-components.mdx b/content/docs/hu-HU/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/hu-HU/guides/plugin/browsing-serverjar.mdx b/content/docs/hu-HU/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/hu-HU/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/hu-HU/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/hu-HU/guides/plugin/build-and-test.mdx b/content/docs/hu-HU/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/hu-HU/guides/plugin/chat-formatting.mdx b/content/docs/hu-HU/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/hu-HU/guides/plugin/chat-formatting.mdx
+++ b/content/docs/hu-HU/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/hu-HU/guides/plugin/client-inputs-reference.mdx b/content/docs/hu-HU/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/hu-HU/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/hu-HU/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/hu-HU/guides/plugin/creating-block.mdx b/content/docs/hu-HU/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/hu-HU/guides/plugin/creating-block.mdx
+++ b/content/docs/hu-HU/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/hu-HU/guides/plugin/creating-commands.mdx b/content/docs/hu-HU/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/hu-HU/guides/plugin/creating-commands.mdx
+++ b/content/docs/hu-HU/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/hu-HU/guides/plugin/creating-configuration-file.mdx b/content/docs/hu-HU/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/hu-HU/guides/plugin/creating-events.mdx b/content/docs/hu-HU/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/hu-HU/guides/plugin/creating-events.mdx
+++ b/content/docs/hu-HU/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/hu-HU/guides/plugin/customizing-camera-controls.mdx b/content/docs/hu-HU/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/hu-HU/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/hu-HU/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/hu-HU/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/hu-HU/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/hu-HU/guides/plugin/instances.mdx b/content/docs/hu-HU/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/hu-HU/guides/plugin/inventory-management.mdx b/content/docs/hu-HU/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/hu-HU/guides/plugin/inventory-management.mdx
+++ b/content/docs/hu-HU/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/hu-HU/guides/plugin/item-interaction.mdx b/content/docs/hu-HU/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/hu-HU/guides/plugin/listening-to-packets.mdx b/content/docs/hu-HU/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/hu-HU/guides/plugin/logging.mdx b/content/docs/hu-HU/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/hu-HU/guides/plugin/player-death-event.mdx b/content/docs/hu-HU/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/hu-HU/guides/plugin/player-input-guide.mdx b/content/docs/hu-HU/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/hu-HU/guides/plugin/player-input-guide.mdx
+++ b/content/docs/hu-HU/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/hu-HU/guides/plugin/player-stats.mdx b/content/docs/hu-HU/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/hu-HU/guides/plugin/setting-up-env.mdx b/content/docs/hu-HU/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/hu-HU/guides/plugin/setting-up-env.mdx
+++ b/content/docs/hu-HU/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/hu-HU/guides/plugin/spawning-entities.mdx b/content/docs/hu-HU/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/hu-HU/guides/plugin/spawning-entities.mdx
+++ b/content/docs/hu-HU/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/hu-HU/guides/plugin/spawning-npcs.mdx b/content/docs/hu-HU/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/hu-HU/guides/plugin/store-persistant-data.mdx b/content/docs/hu-HU/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/hu-HU/guides/plugin/teleporting-players.mdx b/content/docs/hu-HU/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/hu-HU/guides/plugin/teleporting-players.mdx
+++ b/content/docs/hu-HU/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/hu-HU/guides/plugin/text-hologram.mdx b/content/docs/hu-HU/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/hu-HU/guides/plugin/ui.mdx b/content/docs/hu-HU/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/hu-HU/guides/plugin/world-gen.mdx b/content/docs/hu-HU/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/hu-HU/guides/plugin/world-gen.mdx
+++ b/content/docs/hu-HU/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/hu-HU/guides/prefabs.mdx b/content/docs/hu-HU/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/hu-HU/guides/prefabs.mdx
+++ b/content/docs/hu-HU/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/hu-HU/official-documentation/npc-doc.mdx b/content/docs/hu-HU/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/hu-HU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/hu-HU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/hu-HU/publishing/builtbybit.mdx b/content/docs/hu-HU/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/hu-HU/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/hu-HU/publishing/index.mdx b/content/docs/hu-HU/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/hu-HU/publishing/index.mdx
+++ b/content/docs/hu-HU/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/id-ID/guides/ecs/entity-component-system.mdx b/content/docs/id-ID/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/id-ID/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/id-ID/guides/ecs/example-ecs-plugin.mdx b/content/docs/id-ID/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/id-ID/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/id-ID/guides/ecs/hytale-ecs-theory.mdx b/content/docs/id-ID/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/id-ID/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/id-ID/guides/ecs/systems.mdx b/content/docs/id-ID/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/id-ID/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/id-ID/guides/java-basics/00-introduction.mdx b/content/docs/id-ID/guides/java-basics/00-introduction.mdx
index e774e500..c68ece59 100644
--- a/content/docs/id-ID/guides/java-basics/00-introduction.mdx
+++ b/content/docs/id-ID/guides/java-basics/00-introduction.mdx
@@ -25,7 +25,7 @@ Sebelum kita terjun ke pemrograman, kamu memerlukan beberapa hal penting, kamu p
 
 ### Java Development Kit (JDK)
 
-Unduh dan instal JDK 25 atau yang lebih baru dari situs [web resmi Oracle](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) atau gunakan alternatif open-source seperti [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
 ### Integrated Development Environment (IDE)
 
diff --git a/content/docs/id-ID/guides/java-basics/06-methods-functions.mdx b/content/docs/id-ID/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/id-ID/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/id-ID/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/id-ID/guides/plugin/block-components.mdx b/content/docs/id-ID/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/id-ID/guides/plugin/browsing-serverjar.mdx b/content/docs/id-ID/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/id-ID/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/id-ID/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/id-ID/guides/plugin/build-and-test.mdx b/content/docs/id-ID/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/id-ID/guides/plugin/chat-formatting.mdx b/content/docs/id-ID/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/id-ID/guides/plugin/chat-formatting.mdx
+++ b/content/docs/id-ID/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/id-ID/guides/plugin/client-inputs-reference.mdx b/content/docs/id-ID/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/id-ID/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/id-ID/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/id-ID/guides/plugin/creating-block.mdx b/content/docs/id-ID/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/id-ID/guides/plugin/creating-block.mdx
+++ b/content/docs/id-ID/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/id-ID/guides/plugin/creating-commands.mdx b/content/docs/id-ID/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/id-ID/guides/plugin/creating-commands.mdx
+++ b/content/docs/id-ID/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/id-ID/guides/plugin/creating-configuration-file.mdx b/content/docs/id-ID/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/id-ID/guides/plugin/creating-events.mdx b/content/docs/id-ID/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/id-ID/guides/plugin/creating-events.mdx
+++ b/content/docs/id-ID/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/id-ID/guides/plugin/customizing-camera-controls.mdx b/content/docs/id-ID/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/id-ID/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/id-ID/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/id-ID/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/id-ID/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/id-ID/guides/plugin/instances.mdx b/content/docs/id-ID/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/id-ID/guides/plugin/inventory-management.mdx b/content/docs/id-ID/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/id-ID/guides/plugin/inventory-management.mdx
+++ b/content/docs/id-ID/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/id-ID/guides/plugin/item-interaction.mdx b/content/docs/id-ID/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/id-ID/guides/plugin/listening-to-packets.mdx b/content/docs/id-ID/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/id-ID/guides/plugin/logging.mdx b/content/docs/id-ID/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/id-ID/guides/plugin/player-death-event.mdx b/content/docs/id-ID/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/id-ID/guides/plugin/player-input-guide.mdx b/content/docs/id-ID/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/id-ID/guides/plugin/player-input-guide.mdx
+++ b/content/docs/id-ID/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/id-ID/guides/plugin/player-stats.mdx b/content/docs/id-ID/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/id-ID/guides/plugin/setting-up-env.mdx b/content/docs/id-ID/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/id-ID/guides/plugin/setting-up-env.mdx
+++ b/content/docs/id-ID/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/id-ID/guides/plugin/spawning-entities.mdx b/content/docs/id-ID/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/id-ID/guides/plugin/spawning-entities.mdx
+++ b/content/docs/id-ID/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/id-ID/guides/plugin/spawning-npcs.mdx b/content/docs/id-ID/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/id-ID/guides/plugin/store-persistant-data.mdx b/content/docs/id-ID/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/id-ID/guides/plugin/teleporting-players.mdx b/content/docs/id-ID/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/id-ID/guides/plugin/teleporting-players.mdx
+++ b/content/docs/id-ID/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/id-ID/guides/plugin/text-hologram.mdx b/content/docs/id-ID/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/id-ID/guides/plugin/ui.mdx b/content/docs/id-ID/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/id-ID/guides/plugin/world-gen.mdx b/content/docs/id-ID/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/id-ID/guides/plugin/world-gen.mdx
+++ b/content/docs/id-ID/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/id-ID/guides/prefabs.mdx b/content/docs/id-ID/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/id-ID/guides/prefabs.mdx
+++ b/content/docs/id-ID/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/id-ID/official-documentation/npc-doc.mdx b/content/docs/id-ID/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/id-ID/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/id-ID/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/id-ID/publishing/builtbybit.mdx b/content/docs/id-ID/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/id-ID/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/id-ID/publishing/index.mdx b/content/docs/id-ID/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/id-ID/publishing/index.mdx
+++ b/content/docs/id-ID/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/it-IT/guides/ecs/entity-component-system.mdx b/content/docs/it-IT/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/it-IT/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/it-IT/guides/ecs/example-ecs-plugin.mdx b/content/docs/it-IT/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/it-IT/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/it-IT/guides/ecs/hytale-ecs-theory.mdx b/content/docs/it-IT/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/it-IT/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/it-IT/guides/ecs/systems.mdx b/content/docs/it-IT/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/it-IT/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/it-IT/guides/java-basics/00-introduction.mdx b/content/docs/it-IT/guides/java-basics/00-introduction.mdx
index 11944e3e..b2bc6e60 100644
--- a/content/docs/it-IT/guides/java-basics/00-introduction.mdx
+++ b/content/docs/it-IT/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Prima d'immergerci nella programmazione, avrai bisogno di alcuni essenziali, dov
 
 ### Java Development Kit (JDK)
 
-Scarica e installa JDK 25 o superiore dal [sito ufficiale di Oracle](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) oppure usa un'alternativa open-source come [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Integrated Development Enviroment (IDE)
+### Integrated Development Environment (IDE)
 
 Un IDE è un'applicazione software che fornisce servizi completi ai programmatori per lo sviluppo di software. Alcune scelte popolari per Java includono:
 
diff --git a/content/docs/it-IT/guides/java-basics/06-methods-functions.mdx b/content/docs/it-IT/guides/java-basics/06-methods-functions.mdx
index e9b6c040..2c345881 100644
--- a/content/docs/it-IT/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/it-IT/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contiene almeno un numero
    * Restituisce vero se valido, falso altrimenti
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Errori Comuni
 
 ```java
diff --git a/content/docs/it-IT/guides/plugin/block-components.mdx b/content/docs/it-IT/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/it-IT/guides/plugin/browsing-serverjar.mdx b/content/docs/it-IT/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/it-IT/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/it-IT/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/it-IT/guides/plugin/build-and-test.mdx b/content/docs/it-IT/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/it-IT/guides/plugin/chat-formatting.mdx b/content/docs/it-IT/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/it-IT/guides/plugin/chat-formatting.mdx
+++ b/content/docs/it-IT/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/it-IT/guides/plugin/client-inputs-reference.mdx b/content/docs/it-IT/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/it-IT/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/it-IT/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/it-IT/guides/plugin/creating-block.mdx b/content/docs/it-IT/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/it-IT/guides/plugin/creating-block.mdx
+++ b/content/docs/it-IT/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/it-IT/guides/plugin/creating-commands.mdx b/content/docs/it-IT/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/it-IT/guides/plugin/creating-commands.mdx
+++ b/content/docs/it-IT/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/it-IT/guides/plugin/creating-configuration-file.mdx b/content/docs/it-IT/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/it-IT/guides/plugin/creating-events.mdx b/content/docs/it-IT/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/it-IT/guides/plugin/creating-events.mdx
+++ b/content/docs/it-IT/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/it-IT/guides/plugin/customizing-camera-controls.mdx b/content/docs/it-IT/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/it-IT/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/it-IT/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/it-IT/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/it-IT/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/it-IT/guides/plugin/instances.mdx b/content/docs/it-IT/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/it-IT/guides/plugin/inventory-management.mdx b/content/docs/it-IT/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/it-IT/guides/plugin/inventory-management.mdx
+++ b/content/docs/it-IT/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/it-IT/guides/plugin/item-interaction.mdx b/content/docs/it-IT/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/it-IT/guides/plugin/listening-to-packets.mdx b/content/docs/it-IT/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/it-IT/guides/plugin/logging.mdx b/content/docs/it-IT/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/it-IT/guides/plugin/player-death-event.mdx b/content/docs/it-IT/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/it-IT/guides/plugin/player-input-guide.mdx b/content/docs/it-IT/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/it-IT/guides/plugin/player-input-guide.mdx
+++ b/content/docs/it-IT/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/it-IT/guides/plugin/player-stats.mdx b/content/docs/it-IT/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/it-IT/guides/plugin/setting-up-env.mdx b/content/docs/it-IT/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/it-IT/guides/plugin/setting-up-env.mdx
+++ b/content/docs/it-IT/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/it-IT/guides/plugin/spawning-entities.mdx b/content/docs/it-IT/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/it-IT/guides/plugin/spawning-entities.mdx
+++ b/content/docs/it-IT/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/it-IT/guides/plugin/spawning-npcs.mdx b/content/docs/it-IT/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/it-IT/guides/plugin/store-persistant-data.mdx b/content/docs/it-IT/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/it-IT/guides/plugin/teleporting-players.mdx b/content/docs/it-IT/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/it-IT/guides/plugin/teleporting-players.mdx
+++ b/content/docs/it-IT/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/it-IT/guides/plugin/text-hologram.mdx b/content/docs/it-IT/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/it-IT/guides/plugin/ui.mdx b/content/docs/it-IT/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/it-IT/guides/plugin/world-gen.mdx b/content/docs/it-IT/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/it-IT/guides/plugin/world-gen.mdx
+++ b/content/docs/it-IT/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/it-IT/guides/prefabs.mdx b/content/docs/it-IT/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/it-IT/guides/prefabs.mdx
+++ b/content/docs/it-IT/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/it-IT/official-documentation/npc-doc.mdx b/content/docs/it-IT/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/it-IT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/it-IT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/it-IT/publishing/builtbybit.mdx b/content/docs/it-IT/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/it-IT/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/it-IT/publishing/index.mdx b/content/docs/it-IT/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/it-IT/publishing/index.mdx
+++ b/content/docs/it-IT/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/ja-JP/contributing/index.mdx b/content/docs/ja-JP/contributing/index.mdx
index fb90968e..0fee36fc 100644
--- a/content/docs/ja-JP/contributing/index.mdx
+++ b/content/docs/ja-JP/contributing/index.mdx
@@ -1,5 +1,5 @@
 ---
-title: Contributing
+title: 貢献
 ---
 
 # HytaleModdingに貢献する
diff --git a/content/docs/ja-JP/contributing/pr-guidelines.mdx b/content/docs/ja-JP/contributing/pr-guidelines.mdx
index c0fbddd3..7c1e17d9 100644
--- a/content/docs/ja-JP/contributing/pr-guidelines.mdx
+++ b/content/docs/ja-JP/contributing/pr-guidelines.mdx
@@ -10,30 +10,30 @@ description: プルリクエストの提出時とレビュー時に、コント
 ## コントリビューター
 
 1. **明瞭なタイトルと説明**
-   - Use clear and concise titles that summarize the changes.
+   - 変更内容をまとめた明確で簡潔なタイトルを使用してください。
    - PRで行うこと、変更が必要な理由、および関連する情報を詳しく説明してください。
 2. **Issueへのリンク**
    - 関連するIssueとPRをリンクさせるために、PRのタイトルに GH-ISSUE-NUMBER を追加してください。 これはすべてのPRに適用されます。
-3. **Small, Focused Changes**
-   - Aim to keep PRs small and focused on a single issue or feature. This makes it easier for reviewers to understand and provide feedback.
+3. **小規模で集中した変更**
+   - PRを小さく保ち、単一の問題や機能に焦点を当てることを目指してください。 これにより、レビュワーが理解しフィードバックを提供しやすくなります。
 4. **コードの品質**
-   - Ensure your code follows the project's coding standards and best practices.
+   - コードがプロジェクトのコーディング基準とベストプラクティスに従っていることを確認してください。
    - 複雑なロジックの説明が必要な箇所にはコメントを付けてください。
 5. **テスト**
-   - Test your changes thoroughly before submitting the PR.
-   - If applicable, include unit tests or integration tests to verify your changes.
-6. レビュアー
-   - Update or add documentation as needed to reflect your changes.
-7. **Commit Messages**
-   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
-8. **Check for Conflicts**
-   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+   - PRを提出する前に、変更を徹底的にテストしてください。
+   - 該当する場合は、変更を検証するための単体テストまたは統合テストを含めてください。
+6. **ドキュメント**
+   - 必要に応じて、変更を反映させるためにドキュメントを更新または追加してください。
+7. **コミットメッセージ**
+   - [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/)の仕様に従った、明瞭でわかりやすいコミットメッセージを添付してください。
+8. **競合の確認**
+   - PRを送信する前に、マージ競合を最小限に抑えるためにブランチがベースブランチに対して最新であることを確認してください。
 
-## For Reviewers
+## レビュアー
 
-- You are supposed to review PRs thoroughly, and request changes if needed.
-- Provide constructive feedback and suggestions for improvement.
-- Verify that the changes meet the project's coding standards and best practices.
-- Deploy the PR using the dokploy integration to ensure the changes work as expected.
-- Ensure that documentation is updated as necessary.
-- Approve the PR only when you are satisfied with the changes and all checks have passed.
+- PRを詳細にレビューし、必要なら修正依頼を出すのがレビュアーの役割です。
+- 建設的なフィードバックと改善のための提案を提供してください。
+- 変更内容がプロジェクトのコーディング基準とベストプラクティスを満たしていることを確認してください。
+- 変更が期待どおりに動作することを保証するために、Dokploy 統合を使用して PR をデプロイしてください。
+- 必要に応じてドキュメントが適切に更新されているか確認してください。
+- 変更内容に納得がいき、すべての確認が完了してから承認してください。
diff --git a/content/docs/ja-JP/contributing/writing-guides.mdx b/content/docs/ja-JP/contributing/writing-guides.mdx
index 55c52ade..d2d0c17a 100644
--- a/content/docs/ja-JP/contributing/writing-guides.mdx
+++ b/content/docs/ja-JP/contributing/writing-guides.mdx
@@ -1,22 +1,22 @@
 ---
-title: Writing Guides
+title: 執筆ガイド
 ---
 
-## Creating a guide file
+## ガイドファイルの作成
 
-To start writing a guide, you need to create a file with extension `.mdx`. You need to create this file inside the `/content/docs/en` directory, now it depends in which section you want to make the guide, so you can decide which folder you should put it in after that.
+ガイドの作成を始めるには、.mdx拡張子のファイルを作成し、 content/docs/enディレクトリ内に配置してください。どの記事にガイドを作成するかによって、フォルダの配置が決まってます。
 
-Suppose I want to make a java basics guide, I'd put it in `/content/docs/en/guides/java-basics`. You'll have to do some digging to find out where you want to place it.
+もしJavaの基本的なガイドを作りたいなら、content/docs/en/guides/java-basicsに配置します。 既存のフォルダ構成から適切な場所を判断してください。
 
 <Callout>
-  If there's already a guide in the section you want to write about, you can just press on the "Edit On GitHub" button on our website and it'll take you to the folder, now you can write in the same folder to have your guide appear in the same section.
+  すでに同じ記事がある場合、サイトの「Edit On GitHub」ボタンを押すと該当フォルダに直接移動し、編集することができます。
 </Callout>
 
 ## Frontmatter
 
-Frontmatter is the metadata of your guide, it tells our website how to display your guide. This needs to be at the very top of the file, which starts with `---` and ends with `---`.
+Frontmatter はガイドのメタデータで、Webサイトにガイドをどう表示するかを指示します。 これはファイルの一番上、'---'で挟まれている部分に記述する必要があります。
 
-Here's an example:
+例
 
 ```mdx
 ---
@@ -28,36 +28,36 @@ authors:
 ---
 ```
 
-Now as you can see, it's pretty self explanatory, you just need to fill in the details for your specific guide. If you don't have a URL you want to link yourself to, just don't write that whole line. Additionally, the authors section is optional, so if you don't want to add it, you can just leave it out although we encourage you to do so and credit yourself.
+ご覧の通りガイドの詳細を記述するだけでOKです。 リンクしたいURLが無い場合は、その行を削除してください。 authors（著者）の記載は任意ですが、明記することを推奨しています。
 
-The indentation in the frontmatter is important, so make sure to keep it consistent with the example.
+Frontmatter の文法は例と同じフォーマットで揃えてください。
 
-## Content Structure
+## コンテンツ構造
 
-You should structure the content of your guide in a clear and organized manner. Here are some tips on how to do that:
+ガイドの中身は、読み手が理解しやすいように整った構造にしてください。 そのためのヒントをいくつか紹介します。
 
-- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
-- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
-- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
-- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
-- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+- **導入**：トピックの概要と読み手が何を学べるかを説明しましょう。
+- **前提条件**：ガイドを読み進める前に必要な環境や事前知識をリストアップしましょう。
+- **段階的な指示**：ガイドの内容を複数の手順として小分けにしましょう。 見出しと小見出しを使用して情報を整理します。
+- **コード例**：重要なポイントを示すコードスニペットを入れてください。 それぞれの例を使用して、詳細に説明をするようにしましょう。
+- **結論**：要点をまとめ、読み手の学習意欲を出させるようにしましょう。
 
-Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+記事が大きくなりそうな場合は、複数のページに分けることで読み手も理解しやすくなります。 誰も、文字の塊のような長文を一気に読みたいとは思いません。
 
-When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+ガイドを作成する際には、読み手がどのように利用するかを考慮する必要があります。多くの人は、内容を詳細に読むよりも、流し読みをしています。 そのため、情報を複数のページに分割し、読み手にとって情報がシンプルなように見せる方が効果的です。 また、箇条書き、番号付きリスト、その他の書式設定の手法を活用して、読みやすくすることも考えてみてください。
 
-## Formatting
+## 書式設定
 
-We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+ガイドの書式設定には[Markdown](https://www.markdownguide.org/)を使用しています。 以下に留意すべきポイントをいくつか紹介します。
 
-- Use headings (`#`, `##`, `###`) to organize your content.
-- Use bullet points and numbered lists for clarity.
-- Use code blocks (\`\`\`) for code snippets.
-- Use links to reference other guides or external resources.
+- 見出し (`#`, `##`, `###`) を使用して内容を整理できます。
+- 箇条書きと番号付きリストを使用するとわかりやすくなります。
+- コードスニペットにはコードブロック (\`\`\`) を使用できます。
+- リンクを添付して、他のガイドや外部リソースを参照できます。
 
-This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+これらは、ほとんどのドキュメントサイトや、Discord などのSNSプラットフォームでよく使われる書式です。
 
-You can also make a Callout to highlight important information or tips. Use the following syntax:
+重要な情報やヒントを強調するために、吹き出しを作成することもできます。 以下の構文を使用してください。
 
 ```mdx
 <Callout>
@@ -66,10 +66,10 @@ You can also make a Callout to highlight important information or tips. Use the
 ```
 
 <Callout>
-  This is a callout message.
+  これは吹き出しのメッセージです。
 </Callout>
 
-You can change the color of the callout by adding a `type` attribute. For example:
+属性`type`を追加することで、吹き出しの色を変更できます 例
 
 ```mdx
 <Callout type="info">
@@ -77,10 +77,10 @@ You can change the color of the callout by adding a `type` attribute. For exampl
 </Callout>
 ```
 
-Available types are: `info`, `warning`, `error`, and `success`.
+利用可能なtypeは次のとおりです。`info` `warning` `error`  `success`
 
-## Conclusion
+## 終わりに
 
-That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+これで完了です！ あなたはすでにガイド作成のプロです。 完璧な英語である必要はありません。誰かに説明するようなイメージでガイドを書いてください。必要であればフェードバックや助けを求めることもできます。
 
-Happy writing!
+楽しい執筆ライフを！
diff --git a/content/docs/ja-JP/established-information/client/index.mdx b/content/docs/ja-JP/established-information/client/index.mdx
index 39e863f6..d49a8f6e 100644
--- a/content/docs/ja-JP/established-information/client/index.mdx
+++ b/content/docs/ja-JP/established-information/client/index.mdx
@@ -1,69 +1,68 @@
 ---
-title: The Hytale Client
-description: Information regarding the Hytale client.
+title: Hytaleクライアント
+description: Hytaleクライアントに関する情報。
 ---
 
 <Callout>
-  The client is written in C#, compiled to machine code before distribution, and not moddable. Single-player runs on a local server. All mods must go through the server API.
+  クライアントはC#で作成され、配布前に機械語にコンパイルされます。MODの対応はしていません。 シングルプレイヤーはローカルサーバー上で動作します。 すべてのMODはサーバーAPIを経由する必要があります。
 </Callout>
 
-# No Client-Side Mods
+# クライアント用のMODはありません
 
-There is no client-side modding.
+クライアント側で改造することはできません。
 
-> We don't intend to support any client mods - Slikey
+> 私たちはクライアント側のMODを一切サポートするつもりはありません - Slikey
 
-## Why?
+## なぜですか？
 
-1. No need to download externally.
-   * Hytale wants to "avoid a fragmented ecosystem where every server requires a different modded client".
+1. 外部からダウンロードする必要はありません。
+   * Hytaleは、「プレイヤーの環境がサーバーごとに異なる改造クライアントを要求することで分断されてしまう状況を避けたい」と考えています。
 
-2. Client security.
-   * Running `.jar` files from third-party sites on the client can easily introduce malware.
-   > [We don't want to expose players] to the security and safety risks that exist on some other modding platform.
+2. クライアントの安全性
+   * 第三者サイトからダウンロードした `.jar` ファイルをクライアント側で起動すると、マルウェアに簡単に感染する可能性があります。
+   > プレイヤーをほかのMODプラットフォームで見られるような、セキュリティや安全上のリスクに晒したくはありません。
 
-3. Client stability.
-   * Hytale may move to other platforms on which client modding is impossible, so they're locking it down early to set the right direction early.
-   > We believe that the results that people get in other block games using client mods can be easily achieved using our server-sided modding. In other block games you have to install a client mod in order to get new blocks, NPCs, UI, etc.Hytale does all of that just by listening to the server. The server will basically "mod" the client temporarily in a really safe way to add and modify your gameplay experience. You could make your very own version of Orbis, using none of our models, music, world generation, combat or anything. You have control and you can rip it all out without ever touching the client. Think about how Roblox works.. You never change your App. You just click on an experience you want and you get all you need without modding your installation itself. - Slikey
+3. クライアントの安定性
+   * Hytaleは、クライアント側のMODを利用できない他のプラットフォームに移行する可能性があるため、早い段階でクライアントMODを厳しく制限し、正しい方向性を確立しようとしています。
+   > 開発者は、他のブロックゲームでクライアントMODを使って実現しているものは、Hytaleのサーバー側のMODで簡単に達成できると考えています。 他のブロックゲームでは、新しいブロック、NPC、UIなどを追加するために、プレイヤーがクライアント側にMODをインストールする必要があります。Hytaleではクライアントを一切変更せず、サーバーからの通信のみでそれらすべてを実現します。 サーバーからクライアントを一時的に「改造」して、プレイ体験を安全に変更・追加します。 オリジナルのOrbisのような独自の世界を、オリジナルのモデル・音楽・ワールド生成・戦闘システムを一切使わずに作成可能です。 クライアントに触れることなく、自由に操作し、すべてを自由にカスタマイズできます。 Robloxの仕組みを考えてみてください。 アプリを変更する必要はありません。 クリックをするだけでMODをインストールしなくても必要なものをすべて手に入れられます - Slikey
 
-## Client Mods are Not Needed
+## クライアント側でMODは必要ありません
 
-The typical use cases for client mods are:
+クライアントMODの一般的な使用例は次のとおりです。
 
-* Cosmetic changes (resource packs, shaders, capes, etc.): servers own visuals, not the client.
-* Performance: the base game will offer necessary performance controls.
-* Accessibility: the base game will be accessible on its own.
-* User Interface: servers own UI, not the client.
+* 見た目の変更（リソースパック、シェーダー、ケープなど）: クライアントではなくサーバーが管理します。
+* パフォーマンス：各種性能の調整はゲームの基盤に組み込まれています。
+* 利便性：快適にプレイできる環境はゲームの基盤に組み込まれています。
+* ユーザーインターフェース：UIはサーバーで管理しています。
 
-### Client-Side Prediction
+### クライアントサイド予測
 
-Hytale uses data-driven client-side prediction to mitigate lag, as all interactions take place on the server and are relayed back to the client. This is already present for some systems but currently limited, though further integration is planned for the future. It's also planned to work with the visual scripting system in the future for further optimization.
+すべての処理がサーバー上で行われ、その結果をクライアントに反映することで発生する遅延を軽減するために、Hytaleはデータ駆動型のクライアントサイド予測を使用しています。 この機能はすで導入されていますが、現在は限定的な使用をしています。将来的にさらなる統合が計画されています。 今後はビジュアルスクリプティングシステムとも連携し、さらに最適化を進める予定です。
 
-## Client-Side Execution
+## クライアント側の実行
 
-The team is exploring allowing execution of code by the client (which is distinct from modding the client; this is code sent from the server), though this is not guaranteed.
+開発チームは、クライアント上でのコード実行（クライアントの改造とは異なり、サーバーから送信されるコードの実行を指す）を許可する可能性を検討中していますが、確定ではありません。
 
-# Models
+# モデル
 
-The client and assets pipeline accepts `.blockymodel`, a custom format for Hytale. The official Blockbench plugin will allow you to export to this format.
+Hytaleはは独自の.`.blockymodel`形式の3Dモデルファイルに対応しています。 Blockbenchで公式プラグインを使用すると、この形式に出力することができます。
 
-# Client Technical Details
+# クライアントの技術詳細
 
-There will only ever be one current, supported version of the client.
+現在サポートされているクライアントのバージョンは常に 1 つだけです。
 
-> Java version will be kept updated by us and right now we are on the latest version (Java 25)
-> The game version will not be selectable to avoid the version jungle we experienced on our hypixel server network. We simply want to make sure that multiplayer networks can rely on players having the latest version of the game to not have to support 15+ versions of the client. - Slikey
+> Javaバージョンは我々で随時更新しており、現在は最新バージョン（Java 25）を使用しています。Hypixelサーバーネットワークで経験したバージョンの乱立を避けるため、ゲームバージョンの選択はできません。 マルチプレイネットワークが、プレイヤーが最新バージョンのゲームを持っていることを前提に設計できるようにし、15個以上のバージョンをサポートする必要がないようにしたいためです。 - Slikey
 
-The client is multithreaded.
+クライアントはマルチスレッド対応です。
 
 ## GUI
 
-The GUI is built from C# bindings using Noesis.
+GUIはNoesisのC#バインディングを使用して構築されています。
 
-## Build System
+## システムの構築
 
-Hytale uses NativeAOT ("Ahead of Time") to build the client, which compiles C# to machine code for distribution. This means that, without reverse-engineering the machine code, mods will have to go through the server API.
+HytaleはNativeAOT ("Ahead of Time", 事前コンパイル)を使用してクライアントをビルドします。これにより、C#が機械語にコンパイルされて配布されます。 これにより、機械語をリバースエンジニアリングでもしない限り、MODはサーバーAPIを経由する必要があるということです。
 
-# Other Information
+# その他の情報
 
-The client has its own versioning and protocol to interact with servers.
+クライアントはサーバーとの通信に特化したの独自バージョン管理と通信プロトコルを持っています。
diff --git a/content/docs/ja-JP/established-information/developer-qa-insights.mdx b/content/docs/ja-JP/established-information/developer-qa-insights.mdx
index 47915c97..bc44f2a6 100644
--- a/content/docs/ja-JP/established-information/developer-qa-insights.mdx
+++ b/content/docs/ja-JP/established-information/developer-qa-insights.mdx
@@ -1,125 +1,125 @@
 ---
-title: Developer Q&A Technical Insights
-description: Comprehensive summary of technical insights from Hytale developers covering architecture, modding, gameplay systems, and development philosophy.
+title: 開発者の質疑応答と技術的な洞察
+description: アーキテクチャ、Mod開発、ゲームプレイシステム、開発哲学を網羅した Hytale 開発者からの技術的洞察の包括的な概要
 ---
 
-# Developer Q&A Technical Insights
+# 開発者の質疑応答と技術的な洞察
 
-This extensive Q&A session with Hytale developers reveals critical technical details about the game's architecture, modding philosophy, gameplay systems, and development approach.
+このHytale開発者との広範な質疑応答では、ゲームのアーキテクチャ・Modding哲学・ゲームプレイシステム・開発アプローチなどについての重要な技術的詳細が明らかになります。
 
-## Technical Architecture
+## 技術的アーキテクチャ
 
-### Network & Infrastructure
+### ネットワークとインフラストラクチャ
 
-* **Protocol**: Uses QUIC (reliable UDP with unreliable channels) instead of TCP
-* **Server Compatibility**: Runs on any platform supporting Java 25
-* **Connection Method**: Direct IP initially, server discovery planned post-launch
-* **Data Layer**: Current custom serialization format will be replaced post-launch
-* **Performance**: Multi-core support - each world has main thread + parallel execution
-* **Rendering**: OpenGL 3.3 for Mac compatibility, potential future Vulkan/Metal migration
-* **Tick Model**: Base server tick rate is 30 TPS by default; can be changed using server plugins.
+* **プロトコル**: TCPの代わりに、QUIC (信頼出来ないチャンネル上での信頼出来るUDP) を使用します
+* **サーバーの互換性**: Java 25 をサポートするあらゆるプラットフォームで実行できます
+* **接続方法**: 最初はIPアドレスでの直接続、リリース後にサービスディスカバリを予定
+* **Data Layer**: 現在のカスタムシリアル化フォーマットはリリース後に置き換えられます
+* **パフォーマンス**: マルチコアサポート - 各ワールドにはメインスレッドと並列実行があります
+* **レンダリング**: Macとの互換性のため、OpenGL 3.3。将来的にはVulkan/Metalへの移行の可能性
+* **Tick Model**: サーバーの基本的なティックレートはデフォルトで30 TPSです。サーバープラグインを使用して変更できます
 
-### Security & Distribution
+### セキュリティと配布
 
-* **No Client-Side Code Execution**: Prevents remote code execution exploits
-* **Downloads Limited To**: Configuration files and assets only
-* **Mod Distribution**: Community platforms (CurseForge, Modrinth), no immediate in-game marketplace
-* **Server Hosting**: Available day 1, no business agreements required (just EULA/TOS)
+* **クライアント側でのコード実行無し**: リモートコード実行の脆弱性を防ぎます
+* **ダウンロードの制限**: 設定ファイルとアセットのみ
+* **Mod配布**: コミュニティプラットフォーム (CurseForge, Modrinth)。ゲーム内のマーケットプレイスは現在ありません
+* **サーバーホスティング**: 初日から利用可能、ビジネス契約は必要ありません (EULA/TOSのみ)
 
-## Modding Capabilities
+## Mod開発でできること
 
-### Server-Side Power
+### サーバーサイドの能力
 
-* **Full Java Access**: Database connections, web requests, any Java functionality
-* **Custom Libraries**: Can create Lua scripting, ML frameworks, or any Java library
-* **Server Modification**: Shared source code allows heavy server modifications
-* **Hot Reload**: Supported for most asset types
-* **Documentation**: Public GitBook planned, though initially sparse
+* **完全なJavaアクセス**: データベース接続、Webリクエスト、あらゆるJavaの機能
+* **カスタムライブラリ**: Luaスクリプト、MLフレームワーク、または任意のJavaライブラリを作成できます
+* **サーバーの改造**: 共有されたソースコードにより、サーバーを自在に改造できます
+* **ホットリロード**: ほとんどの種類のアセットでサポートされています
+* **ドキュメント**: 公開GitBookを予定していますが、最初はまばらです
 
-### Content Creation (No Code Required)
+### コンテンツ作成 (コード不要)
 
-* **World Generation**: Custom biomes and maps without Java
-* **NPCs & Items**: JSON-based configuration
-* **Crafting Recipes**: Data-driven system
-* **Visual Scripting**: Replaces command blocks, fully sandboxed
-* **Prefab System**: Sophisticated building blocks with in-game editor
+* **ワールド生成**: Javaを使用しないカスタムバイオームとマップ
+* **NPCとアイテム**: JSON ベースの設定
+* **クラフトレシピ**: データ駆動システム
+* **ビジュアルスクリプティング**: コマンドブロックの代替, 完全にサンドボックス化されて実行
+* **Prefabシステム**: ゲーム内エディター付きの洗練されたビルディングブロック
 
-### Advanced Modding
+### 高度なModding
 
-* **Combat System**: Data-driven interaction system for attack chains and abilities
-* **Sub-Hitboxes**: Support for complex boss mechanics (needs improvement)
-* **Status Effects**: Buff/debuff system with custom effects and stats
-* **Custom UI**: NoesisGUI transition enables powerful interface customization
-* **Block Physics**: Selective system (trees fall, but placed blocks don't)
+* **戦闘システム**: 攻撃チェーンとアビリティのためのデータ駆動相互作用システム
+* **子当たり判定**: 複雑なボスの仕組みをサポート (改善が必要)
+* **ステータス効果**: カスタムエフェクトとステータスを利用したバフ/デバフシステム
+* **カスタムUI**: NoesisGUIトランジションにより、インターフェイスの強力なカスタマイズが可能になります
+* **ブロック物理学**: 選択的なシステム (木は倒れますが、配置されたブロックは倒れません)
 
-## Gameplay Systems
+## ゲームプレイシステム
 
-### Core Mechanics
+### コアメカニズム
 
-* **Stamina System**: No hunger by default (can be modded in)
-* **Gravity**: Selective block physics - trees collapse, buildings can float
-* **Lighting**: Major overhaul to fix model/voxel inconsistencies
-* **World Height**: Currently limited, may change with voxel storage updates
-* **Automation**: No redstone equivalent at launch (moddable)
+* **スタミナシステム**：空腹度はデフォルトではありません（Modで追加可能）
+* **重力**: 選択的ブロック物理学 - 木は倒れるが、建物は空中に浮かせられます
+* **ライティング**: モデル・ボクセルの不整合を修正するための主要なオーバーホール
+* **ワールドの高さ**: 現在は制限されていますが、Voxelストレージのアップデートで変更される可能性があります
+* **自動化**: リリース時にレッドストーンの代替物はありません (Modで追加可能)
 
-### Player Systems
+### プレイヤーシステム
 
-* **Character Models**: Humans by default, changeable in creative mode
-* **Multiplayer Avatars**: Server-controlled (no custom models in multiplayer)
-* **Skins**: Full customization possible ("mod yourself into a potato")
-* **Shapeshifting**: Transformation potions exist for fun/modding
+* **キャラクターモデル**: デフォルトで人間、クリエイティブモードで変更可能
+* **マルチプレイヤーアバター**: サーバー制御 (マルチプレイヤーではカスタムモデルなし)
+* **スキン** : 完全なカスタマイズが可能 (「自分をジャガイモにする」 など)
+* **変身能力**: 変形ポーションが遊びとModdingのために存在します
 
-### World & NPCs
+### ワールド＆NPC
 
-* **Faction System**: Living world with dynamic NPC interactions
-* **Village Systems**: Planned dynamic villages with relationships and behaviors
-* **Chunk Loading**: Entities unload when out of all players' render distance
-* **Seeds**: Shareable world generation seeds supported
+* **陣営システム**: 動的なNPCの相互作用による生きた世界
+* **村システム**: 関係と行動を持つ動的な村を計画中
+* **チャンクの読み込み**: エンティティはすべてのプレイヤーの描画距離から外れたときにアンロードされます
+* **シード値**: 共有可能なワールド生成シードをサポート
 
-## Development Philosophy
+## 開発哲学
 
-### Release Strategy
+### リリース戦略
 
-* **Base Game Priority**: Adventure mode is primary focus, modding architecture supports it
-* **Tech Debt**: Acknowledged as necessary for release, commitment to improvement
-* **Update Frequency**: Very frequent updates planned, especially post-launch
-* **Version Policy**: Always latest version, but servers can run modified versions
+* **ベースゲームの優先順位**: アドベンチャーモードが主要な焦点で、Moddingアーキテクチャによりそれをサポートする
+* **技術的負債**: リリースのために必要不可欠であるため受け入れるが、改善する意思は持っている
+* **更新頻度**: 非常に頻繁な更新を予定、特にリリース直後
+* **バージョンポリシー**: クライアントは常に最新版のみを利用可能。しかし、サーバーは好きなバージョンを実行可能。
 
-### Community Focus
+### コミュニティへの注力
 
-* **Creator Support**: Development bounties planned for community contributors
-* **Tutorials**: Official modding tutorials planned with partners
-* **Feedback Integration**: Strong commitment to community-driven improvements
-* **Accessibility**: Designed for lower-end hardware, reasonable system requirements
+* **クリエイターサポート**: コミュニティ貢献者のために開発報奨金を計画
+* **チュートリアル**: パートナーと公式Moddingチュートリアルを計画
+* **フィードバックの統合**: コミュニティ主導の改善への強いコミットメント
+* **アクセシビリティ**: 低性能ハードウェア向けに設計されており、システム要件は低め
 
-### Tools & Documentation
+### ツール & ドキュメント
 
-* **Blockbench Integration**: Replaces custom "Hytale Model Maker"
-* **Machinima Tools**: Full cinematic creation capabilities
-* **Creative Tools**: Major reveal planned for building/creation features
-* **Source Access**: Server code will be unobfuscated with developer comments
+* **Blockbench統合**: カスタム「Hytale Model Maker」を置き換えます
+* **Machinima Tools**: 完全なシネマティック作成機能
+* **クリエイティブツール**: 建設/作成機能の大規模公開を計画
+* **ソースコードへのアクセス**: サーバーのコードは非難読化状態・開発者のコメント付きで公開されます
 
-## Platform Support
+## プラットフォームのサポート
 
-* **Current**: Windows (primary)
-* **Planned**: Mac/Linux support actively in development
-* **VR**: Not feasible in near future
-* **Performance**: Uncapped framerate, designed for accessibility
-* **Offline Play**: Single-player works without internet connection
+* **現在**: Windows (主要)
+* **予定**: Mac/Linuxのサポートを積極的に開発中
+* **VR**: 近い将来には実現できません
+* **パフォーマンス**: フレームレートの上限なし、アクセシビリティのために設計
+* **オフラインプレイ**: シングルプレイはインターネット接続なしで動作します
 
-## Monetization & Legal
+## 収益化と法的事項
 
-* **No Pay-to-Win**: Firm commitment against P2W mechanics
-* **Cosmetics Only**: Low-price cosmetic packs to support infrastructure
-* **Server EULA**: Terms being finalized for server monetization policies
-* **QUIC Blocking**: Acknowledged issue in some regions, no alternative protocol
+* **Pay-to-Winなし**: Pay to Winの仕組みは作らないという確固たる方針
+* **装飾のみ**: インフラをサポートするために、低価格のコスメティックパックを販売
+* **サーバーEULA**：サーバーマネタイズポリシーの規約が確定しました
+* **QUICのブロック**: 一部の地域で問題が確認されていますが、代替プロトコルはありません。
 
-## Current Limitations
+## 現在の制限
 
-* **Custom Shaders**: Not supported until sandboxing solution found
-* **UI/Input Limitations**: Being expanded but currently restricted
-* **Documentation**: Sparse initially, will improve over time
-* **Client Mods**: No client-side code execution for security
-* **Nameplates**: Currently limited customization
+* **カスタムシェーダー**: サンドボックス化の方法が見つかるまでサポートされていません
+* **UI/入力の制限**: 拡張予定ですが、現在は制限されています
+* **ドキュメント**: 最初は少ないですが、時間が経つにつれ改善予定です
+* **クライアントMod**: セキュリティのため、クライアントでのコード実行はありません
+* **ネームプレート**: 現在、カスタマイズが制限されています
 
-This comprehensive technical foundation positions Hytale as a secure, extensible platform that empowers creators while maintaining performance, accessibility, and a commitment to continuous improvement.
+この包括的な技術基盤により、Hytaleは、パフォーマンス、アクセシビリティ、継続的な改善へのコミットメントを維持しながら、クリエイターを支援するセキュアで拡張可能なプラットフォームとして位置づけられています。
diff --git a/content/docs/ja-JP/established-information/faq.mdx b/content/docs/ja-JP/established-information/faq.mdx
index f9b651ef..b24228aa 100644
--- a/content/docs/ja-JP/established-information/faq.mdx
+++ b/content/docs/ja-JP/established-information/faq.mdx
@@ -1,45 +1,45 @@
 ---
-title: Frequently Asked Questions
-description: Frequently Asked Questions about Hytale modding.
+title: よくある質問
+description: Hytale Moddingに関するよくある質問
 ---
 
-On this page, we'll answer some of your Frequently Asked Questions.
+このページでは、よく寄せられる質問のいくつかに回答します。
 
-## 1. Can the client be modded?
+## 1. クライアントを改造できますか？
 
-No, the client is not able to be modded, although the Client will not have control over how the game and the UI looks.
+いいえ、クライアントは改造できませんし、ゲームがどう動作するか・UIがどのような見た目かの制御も担っていません。
 
-The server decides the visuals, more like the "Resource Packs" available in Minecraft. The server decides what mods are used
+Minecraft で利用可能な「リソースパック」のように、サーバーが見た目を決定します。 サーバーがMODを使用するかを決定します。
 
-## 2. What Network Protocol will be used?
+## 2. どのネットワークプロトコルが使用されますか？
 
-Hytale will use the QUIC transport protocol.
+Hytale では QUIC トランスポートプロトコルを使用します。
 
-For context, the two main Internet protocols are UDP and TCP.
+背景として、インターネットでの通信にはUDPとTCPという2つの主要な通信プロトコルがあります。
 
-* UDP is connectionless, fast, fire-and-forget packets but has less reliability as packets can be lost.
-* TCP is connection-based, slower than UDP, can guarantee packet delivery with much more reliability.
-  Both are pretty fast in modern times, games can run fine on both (but generally prefer UDP).
+* UDP は、コネクションレス、高速、Fire-and-forget (うちっぱなし)パケットですが、パケットが失われる可能性があるため、信頼性は低くなります。
+* TCPはコネクションベースでUDPよりも遅いですが、パケットの到達を保証できるため信頼性がより高くなります。
+  どちらも現代ではかなり速いですし、ゲームはどちらでも正常に動作できます (しかし、一般には UDP が好まれます)
 
-QUIC is a **hybrid protocol** that builds off UDP to get the same speed benefits, but adds some layers of reliability like TCP.
-Essentially, a solid choice for game development that blends speed and reliability.
+QUIC は**ハイブリッドプロトコル**であり、速度の利点を得るためにUDP上に構築されますが、TCPのような信頼性のためのレイヤーが追加されます。
+基本的に、ゲーム開発では速度と信頼性の両方を取る良い選択肢です。
 
-## 3. What are Transfer Packets?
+## 3. 転送パケットとは？
 
-Transfer packets in Hytale are small data payloads *(4kb)* that allow players to move from one server to another while carrying information.
-They are not equivalent to something like BungeeCord or Velocity and are primarily intended for smaller servers.
+Hytaleにおける転送パケットとは、プレイヤーが情報を保持したままあるサーバーから別のサーバーに移動できるようにする小さなデータ *(4kb)* です。
+これらは BungeeCord や Velocity のようなものではなく、主に小規模なサーバー向けのものです。
 
-Unlike BungeeCord, they do not manage network-wide features such as global plugins.
-Implementing DDOS protection would also be incredibly hard for smaller networks by using transfer packets.
+BungeeCord とは異なり、グローバルプラグインのようなネットワーク全体の機能は管理しません。
+転送パケットを利用してDDOS保護を構築することは、小さなネットワーク向けであっても信じられないほど難しいでしょう。
 
-Transfer packets work quite well in scenarios such as small server networks or hubs where players will hop between servers without the loss of progress. For example, a player might finish a dungeon on one server and then move to a lobby or different game mode with their inventory and stats intact. This lessens server costs and enables the developers to put more effort into gameplay improvement rather than complicated network setups.
+転送パケットは、小規模サーバーのネットワークやハブなど、プレイヤーが進捗を失わずに行き来するような場合には非常にうまく機能します。 例えば、プレイヤーはあるサーバーでダンジョンを攻略し、持ち物や統計情報を維持したままロビーや別のゲームモードに移動するかもしれません。 これにより、サーバーのコストが削減され、開発者は複雑なネットワーク設定よりもゲームプレイの改善に力を入れることができます。
 
-## 4. Will Hytale support dedicated servers?
+## 4. Hytale はサーバー用ソフト (Dedicated Server) をサポートしますか？
 
-Yes, Hytale will support dedicated servers. This allows server owners to host their own Hytale servers on their own hardware or through third-party hosting services.
+はい、Hytaleはサーバー用ソフトをサポートします。 これにより、サーバー所有者は独自のハードウェアまたはサードパーティのホスティングサービスを介して独自の Hytale サーバーをホストすることができます。
 
-Dedicated servers provide more control over server settings, mods, and performance compared to using official hosting solutions.
+サーバー用ソフトは、公式のホスティングサービスに比べて、サーバー設定・Mod・パフォーマンスにおいてより広い範囲を制御できます。
 
-## 5. Will Hytale support modding on consoles?
+## 5. Hytale はコンソールでの Modding をサポートしますか?
 
-As of now, Hytale modding is primarily focused on PC platforms.
+現在、Hytale Moddingは主にPCプラットフォームに焦点を当てています。
diff --git a/content/docs/ja-JP/established-information/gameplay/creative.mdx b/content/docs/ja-JP/established-information/gameplay/creative.mdx
index c2c4e4b4..4cd70fe1 100644
--- a/content/docs/ja-JP/established-information/gameplay/creative.mdx
+++ b/content/docs/ja-JP/established-information/gameplay/creative.mdx
@@ -1,243 +1,244 @@
 ---
-title: Creative
-description: Information regarding the creative mode in Hytale.
+title: クリエイティブ
+description: |
+  Hytaleのクリエイティブモードに関する情報。
 ---
 
-# Creative Mode
+# クリエイティブモード
 
-Creative mode in Hytale is a sandbox mode that allows players to edit the world freely.
+Hytaleのクリエイティブ モードは、プレイヤーが世界を自由に編集できるサンドボックス モードです。
 
-## World Editing Tools
+## ワールド編集ツール
 
-Creative mode includes a variety of tools to help players edit the world. It includes undo functionality for edits.
+クリエイティブモードには、プレイヤーがワールドを編集するのに役立つさまざまなツールが入っています。 これには編集を元に戻す機能も含まれます。
 
-Note that the below sections were unnamed in the video demo of the tools.
+以下の記事にあるツールはデモ映像内では名称が不明なことに注意してください。
 
 ---
 
-### Laser Pointer
+### レーザーポインター
 
-Displays a ray from the player's camera in the direction the player is looking.
+プレイヤーの向いている方向にカメラ位置からまっすぐな線を表示します。
 
-#### Settings
+#### 設定
 
-- Duration (Integer Slider): Description unknown as of December 2025.
-- Laser Color (Hex Color Code): Description unknown as of December 2025.
+- 持続時間（intスライダー）2025年12月時点での詳細は不明です。
+- レーザーの色（16進数カラーコード）2025年12月時点での詳細は不明です。
 
-### Sculpt Brush Tool
+### 地形ブラシツール
 
-Allows the user to raise and lower the terrain to more accurately sculpt and blend shapes. Supports most features of the Paint Brush.
+地形を隆起させたり、より正確に形状を調整・ブレンドできるようにします。 ペイントブラシのほとんどの機能をサポートします。
 
-### Line Brush Tool
+### 直線ブラシツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Selection Tool
+### 選択ツール
 
-Allows the user to select and edit regions of the world by transforming selections of blocks or a prefab via position, rotation, and extrusion.
+世界の領域を選択し、編集できるようにします。ブロックやプレハブの選択範囲を位置・回転・押し出しで変形などができます。
 
-#### Settings
+#### 設定
 
-- Mode (Combo Box: Set, Wall, Fill, Replace): Description unknown as of December 2025.
-- Material (Integer Slider): Description unknown as of December 2025.
-- Weight (Integer Slider): Description unknown as of December 2025.
-- Pitch (Integer): Description unknown as of December 2025.
+- モード（コンボボックス：設定、壁、塗りつぶし、置換）：2025年12月時点での詳細は不明です。
+- マテリアル（intスライダー）2025年12月時点での詳細は不明です。
+- 重さ（intスライダー）：2025年12月時点での詳細は不明です。
+- ピッチ（int）：2025年12月時点での詳細は不明です。
 
-### Ruler
+### 定規
 
-Allows the user to measure distances between multiple points in 3D space, with support for multiple measurement lines and editing of measured points.
+3D空間内の複数の座標間の距離を測定でき、複数の測定ラインと測定済み座標の編集をサポートします。
 
-### Layer Brush Tool
+### レイヤーブラシツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Paste Tool
+### 貼り付けツール
 
-Allows the user to paste a copied selection of blocks or a prefab at the point at which the player is looking. The paste is relative to the selection's anchor point. If the selection is a prefab, the anchor point may be set in the Prefab Editor. It is unknown if the selection's anchor may be set otherwise.
+コピーしたブロックまたはプレハブを、プレイヤーが見ている位置に貼り付けることができます。 貼り付けは、選択されたアンカーポイントを基準に行われます。 選択したものがプレハブの場合、アンカーポイントはプレハブエディターで設定できます。 それ以外の場合、選択したもののアンカーポイントを設定できるかどうかは不明です。
 
-### Flood Brush Tool
+### 塗りつぶしブラシツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Paint Brush Tool
+### ペイントブラシツール
 
-Brushes are used to make large changes to the world from far away.
+このブラシは遠くから世界を大きく改変するために使われます。
 
-#### General Abilities
+#### 基本能力
 
-- Place Shapes and Prefabs
-- Replace Blocks
-- Create Axis Locks and Masks
+- 図形やプレハブを配置する
+- ブロックの置換
+- 軸の移動・回転の固定。編集対象の絞り込み。
 
-#### Settings
+#### 設定
 
-- Material
-- Width (Integer Slider): Description unknown as of December 2025.
-- Height (Integer Slider): Description unknown as of December 2025.
-- Shape (Combo Box: Cube, Sphere, Cylinder, Cone, Inverted Cone, Pyramid, Inverted Pyramid, Cuboid Grid): Description unknown as of December 2025.
-- Origin (Combo Box: Center, Bottom, Top): Description unknown as of December 2025.
-- Mirror Axis (Combo Box: None, Unknown other options): Description unknown as of December 2025.
-- Wall Thickness (Integer Slider): Description unknown as of December 2025.
-- Density (Integer Slider): Description unknown as of December 2025.
+- 材質
+- 重さ（intスライダー）2025年12月時点での詳細は不明です。
+- 高さ（intスライダー）：2025年12月時点での詳細は不明です。
+- 形状（コンボ ボックス：立方体、球、円柱、円錐、逆円錐、角錐、逆角錐、直方体グリッド）：2025年12月時点での詳細は不明です。
+- 原点（コンボ ボックス：中央、下、上）：2025年12月時点での詳細は不明です。
+- ミラー軸 （コンボ ボックス: なし、その他の設定は不明)）：2025年12月時点での詳細は不明です。
+- 壁の厚さ（intスライダー）2025年12月時点での詳細は不明です。
+- 密度（int）：2025年12月時点での詳細は不明です。
 
-#### Presets:
+#### プリセット：
 
-- Boulder: Creates a boulder at the point at which the player is looking.
-- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
-- Rubble: Generate rubble at the point at which the player is looking.
-- Tentacle: TBD
-- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
-- Hot Springs: TBD
-- Ruins: Generates a ruin at the point at which the player is looking.
-- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
-- Grass: TBD
-- Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
-- Ruins: TBD
+- 岩：プレイヤーの見ている位置に岩を生成します。
+- 草の道：プレイヤーの見ている位置にある地形を草の道に変換します。
+- がれき：プレイヤーの見ている位置にがれきを生成します。
+- 触手：未定
+- 溶岩の亀裂：プレイヤーの見ている位置に溶岩の亀裂を生成します。
+- 温泉：未定
+- 遺跡：プレイヤーの見ている位置に溶岩の亀裂を生成します。
+- 遺跡の屋根：プレイヤーの見ている位置に遺跡の屋根を生成します。
+- 芝生：未定
+- 山：プレイヤーの見ている位置に連続した地形の塊を生成します。
+- 遺跡：未定
 
 ---
 
-### Entity Grabber Tool
+### エンティティつかみツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Noise Brush Tool
+### ノイズブラシツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Scatter Brush Tool
+### スプレーブラシツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Extrude Brush Tool
+### 押し出しブラシツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Prefab Selector Tool
+### プレハブ選択ツール
 
-Allows the user to select a prefab when inside the Prefab Editor. May be used with the copy command.
+プレハブエディター内でプレハブを選択できます。 コピーコマンドと併用できます。
 
-### Smooth Brush Tool
+### なめらかブラシツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Hitbox Tool
+### 当たり判定ツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Set Anchor Tool
+### アンカー設定ツール
 
-Allows the user to set an anchor point for a prefab when inside the Prefab Editor.
+プレハブエディター内でプレハブのアンカーポイントを設定できるようにします。
 
-### Tint Brush Tool
+### 色彩ブラシツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
 ---
 
-## Creative Mode Quick Settings
+## クリエイティブモードのクイック設定
 
-Note that these are WIP and subject to change. **Not all settings and functionality are currently known**.
+これらは開発中であり、変更される可能性があります。 **現時点では、すべての設定と機能が明らかになっているわけではありません。**
 
-- Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
-- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
-- Brush Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
-- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
-- Display Legend (Toggle): Description unknown as of December 2025.
-- Show Tool Notifications (Toggle): Description unknown as of December 2025.
-- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
-- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
-- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
-- Flight Intertia (Integer Slider): Description unknown as of December 2025.
-- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
-- No Clip (Toggle): Description unknown as of December 2025.
-- Air Placement (Toggle): Description unknown as of December 2025.
+- ツール到達距離（intスライダー）：2025年12月時点での詳細は不明です。
+- ツールの遅延最小値（intスライダー）：2025年12月時点での詳細は不明です。
+- ブラシの不透明度（intスライダー）：2025年12月時点での詳細は不明です。
+- 選択の不透明度（intスライダー）：2025年12月時点での詳細は不明です。
+- 選択パネルの不透明度（intスライダー）：2025年12月時点での詳細は不明です。
+- ブラシの形状の描画（オンオフ）2025年12月時点での詳細は不明です。
+- 項目の表示（オンオフ）：2025年12月時点での詳細は不明です。
+- ツール通知の表示（オンオフ）：2025年12月時点での詳細は不明です。
+- デフォルトのレーザーポインター（16進数カラーコード）：2025年12月時点での詳細は不明です。
+- ブラシ間隔の有効化（オンオフ）：2025年12月時点での詳細は不明です。
+- ブラシ間の間隔（intスライダー）2025年12月時点での詳細は不明です。 （intスライダー）：2025年12月時点での詳細は不明です。
+- 飛行の慣性（intスライダー）：2025年12月時点での詳細は不明です。
+- 飛行モード（コンボボックス：ホバー、方向）:2025年12月時点での詳細は不明です。
+- 壁抜け（オンオフ）：2025年12月時点での詳細は不明です。
+- 空中配置（オンオフ）：2025年12月時点での詳細は不明です。
 
-## Content Creation Tools
+## コンテンツ作成ツール
 
-Hytale includes a variety of built-in content creation tools to help players create and edit content.
+Hytaleには、プレーヤーがコンテンツを作成、編集できるようにするためのさまざまなツールが入っています。
 
-### Asset Editor
+### アセットエディター
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Model Editor
+### モデルエディター
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Asset Node Editor
+### アセットノードエディター
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### World Tools
+### ワールドツール
 
-These are tools that allow the user to directly edit the current world.
+現在のワールドを直接編集できます。
 
-#### Prefab Editor
+#### プレハブエディター
 
-Allows the user to create or edit prefabs in a separate space.
+別の空間でプレハブを作成、編集できるようにします。
 
-##### Settings
+##### 設定
 
-- Saved configs (Unknown type; presumably a file)
-- Root Dir (Unknown type; presumably a folder)
-- Prefab Paths or Folders (Unknown type; presumably a list of paths or folders)
-- Recursively Search for Prefabs (Toggle)
-- Spawn Entities and NPCs (Toggle)
-- Desired Y Level to Paste (Integer)
-- Blocks Between Prefabs (Integer)
-- WorldGen Type (Combo Box: Flat, Unknown other options): Description unknown as of December 2025.
-- (Flat WorldGen Only) Num Air Blocks Below Prefabs (Integer): Description unknown as of December 2025.
-- Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
-- Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
+- 保存した設定（形式は不明、おそらくファイル）
+- ルートディレクトリ（形式は不明、おそらくフォルダ）
+- プレハブの保存先パスまたはフォルダ（形式は不明、おそらくパスかフォルダのリスト）
+- プレハブを再帰的に検索（オンオフ）
+- エンティティとNPCを生成する（オンオフ）
+- 貼り付け時のY座標（int）
+- プレハブ同士の間隔（int）
+- ワールド生成タイプ （コンボ ボックス： フラット、その他の設定は不明)：2025年12月時点での詳細は不明です。
+- （フラットワールドのみ）プレハブ下の空気ブロック数（int）：2025年12月時点での詳細は不明です。
+- 貼り付けの基準軸（コンボ ボックス： X、その他の設定は不明)：2025年12月時点での詳細は不明です。
+- 配置方法 (コンボ ボックス：アンカー、その他の設定は不明)：2025年12月時点での詳細は不明です。
 
-#### Prefab List
+#### プレハブ一覧
 
-- Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
-- User can pick from server, assets, or worldgen prefabs.
+- 作成したプレハブの一覧を表示します。貼り付けツールに取り込むこともできます。
+- サーバー、アセット、ワールド生成のどれかから選択できます。
 
-#### Spawn NPC
+#### NPC生成
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-#### Spawn Particle
+#### パーティクル生成
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-#### Change Player Model
+#### プレイヤーモデルの変更
 
-- Allows the player to change their model with an adjustable scale.
+- プレイヤーのモデルサイズを自由に変更できます。
 
-#### Tint Chunk
+#### チャンクの色調設定
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-#### Instances
+#### インスタンス
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Builder Tools
+### ビルダーツール
 
-Unknown as of December 2025.
+2025年12月時点での詳細は不明です。
 
-### Machinima
+### マシニマ
 
-Machinima is a built-in sequence editor, allowing the user to create and edit sequences of actions to be played back in game. It includes a built-in interactive keyframe editor.
+マシニマは、ゲーム内の映像からシーケンスを作成、編集し動画を作成できるエディターです。 直感的なキーフレームエディターも入っています。
 
-The speed of playback can be adjusted via commands.
+再生速度はコマンドで調節できます。
 
-The user may add actors for the sequence to control.
+シーケンスを制御できる役者を追加することもできます。
 
-- Reference
-- Camera
-- Entity
-- Item
-- Player
+- 参照
+- カメラ
+- エンティティ
+- アイテム
+- プレイヤー
 
-## Commands
+## コマンド
 
-Commands are entered into the world's chat console and begin with a forward slash `/`.
+コマンドはワールドのチャットで最初に`/`と入力することで使用できます。
 
-- `set <block>`: allows the user to set the blocks in a selection to the specified block.
-- `inventory clear`: allows the user to clear their inventory.
+- `set <block>`：指定した範囲内に選択したブロックを設定します。
+- `inventory clear`：インベントリをリセットします。
diff --git a/content/docs/ja-JP/established-information/server-plugin-insights.mdx b/content/docs/ja-JP/established-information/server-plugin-insights.mdx
index 40c8ae52..52924f51 100644
--- a/content/docs/ja-JP/established-information/server-plugin-insights.mdx
+++ b/content/docs/ja-JP/established-information/server-plugin-insights.mdx
@@ -1,36 +1,35 @@
 ---
-title: Server Code Insights
-description: Slikey shared some insights about server code on 12/15/2025. This document covers key points and takeaways from that discussion.
+title: サーバーのコードの洞察
+description: Slikey氏は、2025年12月15日にサーバーのコードについていくつかの洞察を共有した。 この文書では、その議論からの主要なポイントと要点について説明します。
 ---
 
-<Callout type="info" title="Note">
-  The following information is based on insights shared by Technical Director Slikey on December 15, 2025 on the Hytale Discord Server. It provides an overview of the server code architecture and plugin capabilities.
+<Callout type="info" title="注意">
+  以下の情報は、2025年12月15日にHytale Discord Serverに掲載された、技術ディレクターのSlikey氏が共有した洞察に基づいています。 これは、サーバコードのアーキテクチャとプラグインの機能の概要を提供します。
 
-  Majority of this document is just straight quotes from Slikey with minimal commentary. It is more over to preserve the information shared rather than reword it.
+  この文書のほとんどはSlikey氏からの直接の引用であり、最小限のコメントが付けられています。 共有された情報をありのままに保存することを重要視しています。
 </Callout>
 
-# Server Source Code
+# サーバーのソース コード
 
-The server will be released as shared source - we will have the source code with no obfuscation and all their comments.
+サーバーは、共有ソースとしてリリースされます - 私達は、難読化無し・コメント付きでソースコードを入手出来ます。
 
-### License
+### ライセンス
 
-The license permits usage for any **hytale related** things, so as long as you dont use the server / source to make your own game or sell their algorithms.
+**Hytaleに関連するもの**での利用が許可されます。サーバーやソースコードを利用して自分のゲームを作ったりアルゴリズムを売ったりすることは許可されません。
 
-# Permission system
+# 権限システム
 
-After being asked in the Hytale Modding server, Lead Architect Zero has replied:
+Hytale Moddingサーバーで尋ねられた後、リードアーキテクトのZeroは次のように返信しました。
 
-It's quite basic, so don't expect much but yes we do have a permissions system built in. It also support implementing your own backend. Ex. if you wanted to store it in a database.
+非常に基本的な物なので、あまり期待して欲しくないですが、権限システムが組み込まれています。 また、独自のバックエンドの実装もサポートします。 例: データベースに保存したい場合。
 
-![Premission Source Snippet](/assets/premission-system.png)
+![権限システムのコードスニペット](/assets/premission-system.png)
 
-# World Gen Implementation
+# ワールド生成の実装
 
-The following block of text is directly from Lead Architect Zero:
+次の文章は、リードアーキテクトのZeroによるものです。
 
-You can totally implement a custom world gen in a plugin super easy. So if you want a totally different config or logic for generating terrain you can add that into a plugin and then configure a world to use that,
-We have some stuff load prefabs and there is existing code in the current world generators that could possibly be reused but no APIs specifically for the details of the generation itself.
+プラグインにより、完全にカスタムしたワールド生成を簡単に実装出来ます。 地形を生成するための完全に異なる設定やロジックが必要な場合は、プラグインに実装してワールドでそれを利用するように設定できます。プレハブをロードするためのものや再利用可能なものが既存のワールド生成のコードにありますが、地形生成そのものについての詳細なAPIはありません。
 
 ```java
 public interface IWorldGenProvider {
@@ -59,35 +58,34 @@ public interface IWorldGen {
 }
 ```
 
-# Server Code Snippets
+# サーバーのコードスニペット
 
-Some code snippets from a plugin they made were also shared. The following snippets are directly quoted from Technical Director Slikey:
+彼らが作ったプラグインからのコードスニペットも共有されました。 以下のスニペットは、技術ディレクターであるSlikeyのものからの引用です。
 
-## BlockSpawner Plugin
+## BlockSpawner プラグイン
 
-Alright, I'll drop some code snippets here for a simple plugin called "BlockSpawner" which will turn into a "random" block when put into the world based on the configured rules
+"BlockSpawner"という、設定されたルールに基づいて世界に配置されたときに「ランダム」なブロックに変わる簡単なプラグインのコードスニペットを共有します。
 
-There is more code here in general but it shows the Asset System and the plugin layout. You can see that the asset system defines "Codecs" which are used to serialize and deserialize data. Using these codecs we can generate schemas.
-Let's say you connect to a server and open the asset editor: the server will send those schemas - so every single asset type defined server side, even you own, now become part of the asset editor on the client - no need to do anything, you just get to enjoy the editor UI for making your assets that you defined
+一般的に、ここにはより多くのコードがありますが、それはアセットシステムとプラグインのレイアウトに関するものです。 アセットシステムがデータをシリアライズおよびデシリアライズするために使用する「コーデック」を定義していることがわかります。 これらのコーデックを使用してスキーマを生成できます。
+例えばサーバーに接続してアセットエディタを開くと、サーバーはアセットのスキーマを自動的に送信します。その結果、サーバー側で定義されているすべてのアセットタイプ（自分で定義したものも含めて）が、クライアント側のアセットエディタにそのまま反映されます。特別な設定や作業は不要で、定義したアセットを作成するためのエディタUIをすぐに利用できます。
 
 ![Block Spawner Code 1](/assets/blockspawner-code-1.png)
 ![Block Spawner Code 2](/assets/blockspawner-code-2.png)
 ![Block Spawner Code 3](/assets/blockspawner-code-3.png)
 ![Block Spawner Manifest](/assets/blockspawner-manifest.png)
 
-> i guess this part also shows a bit how we use constants to store some language keys - Slikey
-> (in reference to the image below)
+> この部分は、言語キーを格納するために定数を使用する方法も少し示していると思います - Slikey
+> (下の画像を参照)
 
-![Constants to store Language Keys](/assets/constants.png)
+![言語キーを格納するための定数](/assets/constants.png)
 
-> you can completely customize the chunk storage provider, we for example made one that is just empty where it doesnt load any chunks from disk
-> you could add an MySQLChunkStorageProvider and it could read the data from a database
-> and the same goes for worldgen, you can simply implement this interface to generate a world generator - slikey
+> チャンクのストレージプロバイダーを完全にカスタマイズすることもできます。例として、ディスクからチャンクを一切読み込まない空のストレージプロバイダーを作ります。
+> 例えば MySQLChunkStorageProvider (MySQLを利用したチャンクのストレージプロバイダー) を追加することができるし、ワールド生成でも同様です。ワールド生成器を作るためにはこのインターフェースを実装するだけです。 - slikey
 
 ![Chunks 1](/assets/chunks-1.png)
 ![Chunks 2](/assets/chunks-2.png)
 ![Chunks 3](/assets/chunks-3.png)
 
-> i mean here are all the weapons defined, you tell me, obviously you will discover limitations but i think there is plenty of room to make changes - this stuff is actually hard though, there is a lot of QoL to have happen here
+> つまり、使える武器の定義はすべて公開しているので、実際に見てもらえれば分かると思います。もちろん制限は見つかるでしょうが、変更や調整を行える余地は十分にあります。ただ、この仕組み自体を作るのは正直かなり大変で、今後さらに多くの QoL 改善が必要だと考えています。
 
 ![Weapons 1](/assets/weapons-1.png)
diff --git a/content/docs/ja-JP/established-information/server/content-categories/art-assets.mdx b/content/docs/ja-JP/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..d7e9c8f6 100644
--- a/content/docs/ja-JP/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/ja-JP/established-information/server/content-categories/art-assets.mdx
@@ -1,123 +1,123 @@
 ---
-title: Modelling & Texturing / Art Assets
-description: Information about 3D Modelling, Texturing and Art Assets in Hytale.
+title: モデリング＆テクスチャ / アート素材
+description: Hytaleのモデリング、テクスチャ、アート素材に関する情報
 ---
 
-# Modelling / Texture Art
+# モデリング・テクスチャ
 
-Hytale provides comprehensive support for 3D modeling and texture art creation, with specialized tools and workflows designed to maintain the game's distinctive visual style while empowering creators.
+Hytaleは3Dモデリングとテクスチャ制作を全面的にサポートしており、ゲームの独特スタイルを保ちつつ、クリエイターの創作を力強く後押しするための専用のツールと作業フローを提供します。
 
-## Current Mod Tooling
+## 現在のMODツール
 
 ### Blockbench
 
-Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
+Hytaleは3Dモデリングとアニメーションの制作に**Blockbench**をメインに使用しています。
 
-* **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
-* **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
-* **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
-* **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
+* **公式サポート**：Hytaleのモデル、テクスチャ、アニメーションに使用されています。
+* **独自のプラグイン**：Hytaleには専用のBlockbenchプラグインが用意されます。これはできるだけ早くリリースされます。
+* **直接的な互換性**：Blockbench内で直接Hytaleのモデル、テクスチャ、アニメーションを作成することができます
+* **古いツールを置き換える**：コミュニティで親しまれてきた方法をサポートするため、古いモデリングソフトを置き換えます。
+* **安全機能**：互換性のある要素だけをエンジンに追加できるので、破損の心配はありません。
 
-## Model Constraints
+## モデルの制約
 
-### Geometry Types
+### ジオメトリの種類
 
-The vast majority of models in Hytale are constrained to specific geometric primitives:
+Hytaleのモデルは主に立方体と四角形のみという特定の基本形状に限定されている。
 
-**3D Elements**:
+**3Dの要素**
 
-* Blocks
-* Cuboids
-* Boxes
+* ブロック
+* 直方体
+* 立方体
 
-**2D Elements**:
+**2Dの要素**
 
-* Quads
-* Rectangles
-* Planes (composed of 2 triangles)
+* 四角形
+* 長方形
+* 平面（2つの三角形で構成される）
 
-### Design Philosophy
+### デザインの考え方
 
-These constraints serve multiple purposes:
+これらの制約はいくつかの目的があります。
 
-* **Performance optimization**: Ensures efficient rendering and game performance
-* **Consistent art style**: Maintains Hytale's distinctive visual aesthetic
-* **Seamless integration**: Makes mods feel more cohesive with the base game
+* **パフォーマンスの最適化**：効率的なレンダリングをゲームパフォーマンスを確保します。
+* **一貫した絵柄**：Hytale独自のボクセル風アートスタイルを維持します。
+* **シームレスな連携**：MODとゲームの一体感を持たせます。
 
-## Pixel Density Standards
+## 解像度の基準
 
-Hytale uses different pixel densities for different types of content:
+Hytaleは、コンテンツの種類よって異なる解像度を使用します。
 
-### Standard Densities
+### 基本の解像度
 
-* **Blocks**: 32px density
-* **Player models**: 64px density
-* **Mobs**: Likely also 64px density
-* **Player equipment**: 64px density (weapons, cosmetics, armor, etc.)
+* **ブロック**：32px
+* **プレイヤーモデル**：64px
+* **モブ**: 同様におそらく64px
+* **プレイヤー装備**: 64px (武器、装飾品、防具など)
 
-### Flexibility
+### 柔軟性
 
-* **Wrong density handling**: Using incorrect density may cause assets to appear at the wrong size, but will not cause import failures
-* **No strict restrictions**: Pixel ratio, rotation, and scaling are not restricted
-* **Forgiving system**: The tools are designed to be flexible while maintaining compatibility
+* **間違った解像度の使用**：解像度の間違いにより、アセットが意図しない大きさで描画される可能性があります。これが原因でインポートに失敗することはありません。
+* **厳しい制限はありません**：ピクセル比、回転、拡大縮小に制限はありません。
+* **寛容なシステム**：ツールは互換性を持つように柔軟に設計されています。
 
-## Hytale Asset Editor
+## Hytaleアセットエディタ
 
-### In-Game Editor
+### ゲーム内エディタ
 
-The Asset Editor is a comprehensive tool that will ship with the game:
+アセットエディタは、ゲームに付属する多機能ツールです。
 
-* **Ships with game**: Available to all players from launch
-* **External tool requirement**: Does not support image editing, you must use external tools for texture creation
-* **Data asset editing**: Primary editor for working with Data Assets
-* **Expanding capabilities**: Currently supports most features, though has limitations around NPCs, worldgen, and interactions that will expand over time
+* **ゲームに付属**：発売時から全プレイヤーが使用可能です。
+* **外部ツールが必要**：画像編集はサポートしていません。テクスチャの作成には外部ツールを使用してください。
+* **データアセットの編集**：データアセットを編集する主要なエディタ。
+* **拡張中の機能**：現在はほとんどの機能に対応していますが、NPC、世界の生成、インタラクションに関する制限があり、今後拡張予定です。
 
-### Particle Creation
+### パーティクルの作成
 
-The Asset Editor includes robust particle creation tools:
+アセットエディタには強力なパーティクル作成ツールが入っています。
 
-* **In-game creation**: Particles are created directly in-game using the Asset Editor
-* **Industry standard**: Particle logic is robust and similar to Unity/Unreal particle systems
-* **Event-driven**: Particles can be spawned on events or interactions (like opening doors)
-* **Entity attachment**: Can attach particles to entities with specific attachment points
-* **Dynamic movement**: Supports particles moving with their anchor points
-* **Time delays**: Supports time-based particle effects and delays
+* **ゲーム内で作成**： パーティクルはアセットエディタを使ってゲーム内で直接作成します。
+* **業界基準**：パーティクルロジックはUnityやUnrealのパーティクルシステムと同じように堅牢です。
+* **イベント駆動**：パーティクルはイベントやインタラクション（ドアを開ける時など）で生成されます。
+* **エンティティのアタッチメント**：特定のアタッチメントポイントを持つエンティティにパーティクルを取り付けることができます。
+* **ダイナミックな動き**：アンカーポイントを使ったパーティクルの移動をサポートします。
+* **時間遅延**：時間ベースのパーティクル効果と遅延をサポート
 
-## Materials
+## マテリアル
 
-### Optimization Focus
+### 最適化の焦点
 
-Hytale takes a different approach to materials compared to other engines:
+Hytaleはマテリアルに対して他のエンジンと異なるアプローチを採用しています。
 
-* **Pre-optimized**: Materials are very optimized and artists cannot create custom materials
-* **Performance priority**: This constraint ensures consistent performance across all content
-* **Curated system**: Maintains visual consistency while maximizing efficiency
+* **事前最適化**：マテリアルは高度に最適化されており、制作者はカスタムマテリアルを作成できません。
+* **パフォーマンスの優先順位**：この制約が全てのコンテンツで一貫したパフォーマンスを保証します。
+* **管理されたシステム**：ビジュアルの一貫性を維持しつつ、効率を最大化します。
 
-## Best Practices
+## ベストプラクティス
 
-### Asset Optimization
+### アセットの最適化
 
-Key considerations from Hytale's development team:
+Hytale開発チームからの重要な考慮点
 
-* **Mindful resource usage**: Be conscious of how many blocks/quads you use and texture file sizes
-* **Avoid bloat**: Goal is to prevent unnecessary asset bloat that could impact performance
-* **Efficiency focus**: Balance visual quality with technical constraints
+* **リソースの使用に注意**：使用する立方体/平面の数、テクスチャのファイルサイズ
+* **肥大化を避ける**：不要なアセット肥大化を防ぎ、パフォーマンスへの影響を防止することが目標にしましょう。
+* **効率重視**：視覚的な品質と技術的な制約のバランス。
 
-### Future Documentation
+### 今後のドキュメント
 
-* **Best practice guide**: A comprehensive "best practice" guide for art and modeling will be released at some point
-* **Flexible boundaries**: Most creative goals can be achieved without breaking anything in the system
-* **Community-driven workflows**: Tools are designed to support established creative workflows in the modding community
+* **ベストプラクティスガイド**: アートとモデリングのための包括的な「ベストプラクティス」ガイドがいつかリリースされます
+* **柔軟な境界**：ほとんどの創作目標は、システムを壊すことなく実現できます。
+* **コミュニティ主導のワークフロー**：ツールは、MOD開発コミュニティで親しまれてきたワークフローをサポートするように設計されています
 
-## Integration with Development Pipeline
+## 開発パイプラインとの連携
 
-The modeling and texture art workflow integrates seamlessly with Hytale's broader development ecosystem:
+モデリング・テクスチャ制作のワークフローはHytale全体の開発環境と完全に連携します。
 
-* **Asset Editor compatibility**: Models created in Blockbench work directly with the Hytale Asset Editor
-* **Data Asset integration**: 3D models can be configured and customized through Data Assets
-* **Visual Scripting support**: Models can be controlled and animated through Visual Scripting
-* **Java plugin extensibility**: Advanced model behaviors can be implemented through Java plugins
-* **Particle integration**: Models can have particles attached at specific points for enhanced visual effects
+* **アセットエディタの互換性**：Blockbenchで作成されたモデルはHytaleアセットエディタで直接動作します。
+* **データアセット連携**：3Dモデルはデータアセットを通じて設定・カスタマイズ可能です。
+* **ビジュアルスクリプティング対応**：モデルはビジュアルスクリプティングで制御・アニメーション可能です。
+* **Javaプラグインの拡張性**：高度なモデル動作はJavaプラグインを通じて実装できます。
+* **パーティクル連携**：モデルの特定の位置にパーティクルを取り付け、視覚効果を高めることができます。
 
-This integrated approach ensures that 3D modeling and texture art aren't isolated creative processes, but core components of Hytale's comprehensive development environment.
+この連携手法により、3Dモデリングとテクスチャ制作は独立した作業ではなく、Hytale開発環境の中心要素となります。
diff --git a/content/docs/ja-JP/established-information/server/content-categories/data-assets.mdx b/content/docs/ja-JP/established-information/server/content-categories/data-assets.mdx
index 1c11ef23..39555e3f 100644
--- a/content/docs/ja-JP/established-information/server/content-categories/data-assets.mdx
+++ b/content/docs/ja-JP/established-information/server/content-categories/data-assets.mdx
@@ -1,61 +1,61 @@
 ---
-title: Data Assets
-description: Information about data assets in Hytale and how they drive gameplay behavior and content creation.
+title: データアセット
+description: Hytaleのデータアセットと、それらがゲームプレイの挙動やコンテンツ作成にどのように活用されるかに関する情報
 ---
 
-# Data Assets
+# データアセット
 
-Data Assets are JSON files which drive gameplay behavior and core content in Hytale. They provide a powerful, data-driven approach to creating and modifying game elements without needing to write code.
+データアセットは、Hytaleのゲームの挙動や主要コンテンツを制御するJSONファイルです。 これは、コードを書かずにゲーム要素を作成・変更できる、強力なデータ駆動型の手法を提供します。
 
-## What Are Data Assets?
+## データアセットとは？
 
-Data Assets allow you to create or modify fundamental game elements through JSON configuration files:
+データアセットを使用すると、JSONの設定ファイルを通じて基本的なゲーム要素を作成したり変更することができます。
 
-* **Blocks**: Define new block types and their properties
-* **Items**: Create custom items with unique behaviors
-* **NPCs**: Configure non-player characters and their AI
-* **World generation**: Control how the world is generated
-* **Loot tables**: Define what items drop from various sources
+* **ブロック**：新しいブロックタイプとプロパティを定義します。
+* **アイテム**：独自の動作を持つカスタムアイテムを作成します。
+* **NPC**: プレイヤー以外のキャラクターとそのAIを設定します。
+* **ワールド生成**： ワールドの生成方法を制御します。
+* **ルートテーブル**：さまざまなソースからどのアイテムがドロップするかを定義します。
 
-## Comparison to Minecraft
+## Minecraftとの比較
 
-Data Assets are analogous to Minecraft's data pack JSON files, but with significantly broader scope. While Minecraft's data packs are somewhat limited, Hytale's data-driven architecture means that core game elements like blocks, items, and NPCs can all be modified through JSON files.
+データアセットはMinecraftのデータパックJSONファイルに似ていますが、それよりも適用範囲が広くなっています。 Minecraftのデータパックにはある程度の制限がありますが、Hytaleのデータ駆動型アーキテクチャでは、ブロック、アイテム、NPCといったゲームの基本要素のすべてをJSONファイルで変更することができます。
 
-This expanded data-driven approach gives modders much more power to customize the game without needing to dive into complex programming.
+この拡張されたデータ駆動型の手法により、MOD開発者は複雑なプログラミングをしなくとも、ゲームをより自由にカスタマイズできるようになります。
 
-## Development Tools
+## 開発ツール
 
-Recognizing that JSON editing can be tedious and error-prone when done by hand, Hytale plans to provide multiple tools to make working with Data Assets more accessible:
+手作業のJSON編集は面倒でミスが起こりやすいことを踏まえ、Hytaleではデータアセットをより扱いやすくするための複数のツールを提供する予定です。
 
-### Node Editor
+### ノードエディター
 
-Hytale is developing a "Node Editor" to make Data Asset management more user-friendly:
+Hytaleは、データアセット管理をよりやりやすくするために「ノードエディター」を開発しています。
 
-* **Visual interface**: Provides a graphical way to work with data relationships
-* **Customization focus**: Particularly helpful for customizing NPCs, interactions, and world generation
-* **Integrated workflow**: Works directly within the Hytale Asset Editor for a unified creator suite
-* **Accessibility**: Makes complex data relationships easier to understand and modify
+* **ビジュアルインターフェース**：データ間の関係を直感的に操作できる方法を提供します。
+* **カスタマイズ重視**：NPC、インタラクション、ワールド生成のカスタマイズに特に役立ちます。
+* **統合されたワークフロー**: Hytale Asset Editor 内で、統合されたクリエーター用ツールとして直接動作します。
+* **アクセシビリティ**：複雑なデータの関係をより理解しやすく、変更しやすくします。
 
-### Additional Tools
+### 追加ツール
 
-Beyond the Node Editor, Hytale plans to support:
+ノード エディター以外にも、Hytaleは次のものをサポートする予定です。
 
-* **Visual JSON generators**: Graphical interfaces for creating JSON without writing syntax
-* **Form-based editors**: Structured forms that generate the appropriate JSON automatically
-* **Multiple workflow options**: Different tools for different comfort levels and use cases
+* **ビジュアルJSONジェネレーター**：構文を書くことなく、直感的なインターフェースでJSONを作成できます。
+* **フォームベースのエディター**：決められた形式を使用して、適切なJSONを自動生成します。
+* **複数のワークフロー選択**：ユーザーの習熟度や用途に応じて異なるツールを利用できます。
 
-## Power and Simplicity
+## パワーとシンプルさ
 
-The effectiveness of Data Assets is demonstrated by their simplicity. For example, making raptors rideable in Hytale reportedly requires only 4 lines of JSON configuration - showcasing how powerful yet accessible the system is designed to be.
+データアセットの有効性は、そのシンプルさによって実証されています。 例えば、Hytaleで鷹や鷲に乗れるようにするには、わずか4行のJSON設定を追加するだけで可能とされています。これは、このシステムがどれほど強力でありながら扱いやすく設計されているかを示しています。
 
-This balance between power and accessibility is central to Hytale's modding philosophy: providing professional-grade tools that don't require programming expertise to use effectively.
+この「高い柔軟性」と「使いやすさ」のバランスこそが、HytaleのMOD開発理論の中心にあります。それは、プログラミングの専門知識がなくても効果的に使える熟練者レベルのツールを提供するという理念です。
 
-## Integration with Other Systems
+## 他のシステムとの連携
 
-Data Assets work seamlessly with Hytale's other development approaches:
+データアセットは、Hytaleの他の開発手法ともシームレスに連携します。
 
-* **Visual Scripting**: Can reference and manipulate data defined in Data Assets
-* **Java plugins**: Can read from and modify Data Assets for more complex behaviors
-* **Asset Editor**: Provides a unified interface for managing both visual assets and their data configurations
+* **ビジュアルスクリプティング**：データアセットで定義されたデータを参照、操作することができます。
+* **Javaプラグイン**：より複雑な動作を実現するために、データアセットを読み取り、変更することができます。
+* **アセットエディター**：ビジュアルアセットとそのデータ設定の両方を管理するための統一されたインターフェースを提供します。
 
-This integration ensures that Data Assets aren't isolated configuration files, but rather a core part of Hytale's comprehensive development environment.
+この連携により、データアセットは単なる独立した設定ファイルではなく、Hytaleの統合開発環境のメインの要素となっています。
diff --git a/content/docs/ja-JP/established-information/server/content-categories/plugin.mdx b/content/docs/ja-JP/established-information/server/content-categories/plugin.mdx
index 5b585924..7048f00e 100644
--- a/content/docs/ja-JP/established-information/server/content-categories/plugin.mdx
+++ b/content/docs/ja-JP/established-information/server/content-categories/plugin.mdx
@@ -1,48 +1,33 @@
 ---
-title: Java Modding (Server Plugins)
-description: An introduction to what we know of Hytale's Java-based modding system as of writing this article.
+title: JavaのMOD開発（サーバープラグイン）
+description: HytaleのJavaベースのModdingシステムについて、この記事を書いている時点で私たちが知っていることを紹介します。
 ---
 
-Hytale's modding capabilities include a Java-based modding system that allows modders
-to create custom behaviors, interactions, and game mechanics. While the full details of
-this system are not publicly documented as the game is still in development and not
-released, we can summarize what is currently known about it.
+HytaleのMOD開発システムには、開発者が独自の動作、インタラクション、ゲームの仕組みを作成できるJavaを基盤にしたMOD開発システムが入っています。 このシステムの詳細は、ゲームがまだ開発中でリリースされていないため、公に文書化されていません。現在知られている情報をまとめると以下のようになります。
 
-### Important Details of Modding in Hytale
+### HytaleのMOD開発に関する重要な詳細
 
-Hytale's modding goes on server side and not client side, meaning that mods/plugins are
-hosted on the server and players connect to these modded servers to experience the custom content
-without needing to install anything on their end. This approach ensures a consistent experience
-for all players on a modded server.
+HytaleのMOD開発はクライアントではなくサーバー側で行われます。MODとプラグインはサーバー上でホストされ、プレイヤーはこれらのMODサーバーに接続することで、何もインストールすることなくカスタムコンテンツを体験できることを意味します。 この手法により、MODサーバー上のすべてのプレイヤーに一貫した体験が保証されます。
 
-### Overview of Java-Based Modding
+### JavaベースのMOD開発の概要
 
-The server-side modding system in Hytale is based on Java, making the server plugins JAR files.
+HytaleのサーバーサイドのMOD開発システムはJavaを基盤としており、サーバー プラグインはJARファイルとなっています。
 
-We're guessing this is done so that Minecraft modders can easily transition to Hytale modding,
-as Minecraft modding is also primarily Java-based. This allows modders familiar with Java
-to leverage their existing knowledge when creating mods for Hytale.
+HytaleのMOD開発がこのように設計されているのは、MinecraftのMOD開発者がJavaを基盤にしたMinecraftのMOD開発からHytaleのMOD開発へ容易に移行できるようにするためだと考えられます。 Javaに慣れているMOD開発者は、Hytale向けのMODを開発する際にすでに学んだ知識を活用することができます。
 
-#### Singleplayer Concerns
+#### シングルプレイヤーの懸念点
 
-Despite the name, server plugins can also be used in singleplayer mode.
-Hytale's singleplayer mode runs a local server instance, allowing players to use server plugins
-even when playing alone. This means that mods created as server plugins can enhance the singleplayer experience as well.
+名前に関係なく、サーバープラグインはシングルプレイヤーモードでも使用できます。
+Hytaleのシングルプレイヤーモードではローカルのサーバーインスタンスが実行されるため、プレイヤーは1人でプレイしていてもサーバープラグインを使用できます。 つまり、サーバープラグインとして作成されたMODは、シングルプレイヤーでも同じような体験をすることができます。
 
-### Mixin System
+### Mixinシステム
 
-Mixins were used in Minecraft modding to directly modify the game’s code, even able to overwrite
-or redirect logic and values. An extremely powerful but somewhat brittle system which depends
-on the source code/game version staying pretty much the same.
+MinecraftのMOD開発では、Mixinを使ってゲームコードを直接変更し、処理や値を上書きしたりリダイレクトしたりすることも可能です。 非常に強力ではありますが、ソースコードとゲームバージョンがほぼ変更されないことに依存する、やや不安定なシステムでした。
 
-We have no official information on Mixins in Hytale. Despite that, we have reason to believe they will not
-need to be supported for the following reasons:
+HytaleにおけるMixinに関する公式情報はまだありません。 ですが以下の理由から、Mixinをサポートする必要はないと考えています。
 
-1. For a properly designed game, 95% of Mixin use cases can be solved with a good API instead.
-   In fact, many Minecraft modding APIs simply mixin to provide the API so the developers using
-   those APIs don’t have to write the mixin themselves.
-   * This is typically replacing hardcoded values and overwriting hardcoded behaviors.
-   * Hytale should ideally make these both API or data-driven.
-2. APIs can also be much more resilient than the game version. We can have a separate API
-   version system which means the same code will not need to be modified across multiple updates
-   until the API changes in a breaking way.
+1. 適切に設計されたゲームであれば、Mixinの使用ケースの95%は優れたAPIによって解決可能です。
+   実際、多くのMinecraftのMOD開発APIはAPIを提供するために単純なMixinを使用しており、それらのAPIを利用する開発者が自分でMixinを書く必要をなくしています。
+   * これは通常、ハードコードされた値を置き換え、動作を上書きします。
+   * 理想を言うならば、HytaleにはこれらをAPIまたはデータ駆動型で提供すべきです。
+2. またAPIはゲームバージョンよりもはるかに堅牢です。 別のAPIバージョン管理システムを導入することで、APIの大規模な変更がない限り、同じコードを何回も修正せずに済みます。
diff --git a/content/docs/ja-JP/established-information/server/content-categories/visual-scripting.mdx b/content/docs/ja-JP/established-information/server/content-categories/visual-scripting.mdx
index 16cb0508..498e4355 100644
--- a/content/docs/ja-JP/established-information/server/content-categories/visual-scripting.mdx
+++ b/content/docs/ja-JP/established-information/server/content-categories/visual-scripting.mdx
@@ -1,59 +1,59 @@
 ---
-title: Visual Scripting
-description: An introduction to what we know of Hytale's visual scripting system as of writing this.
+title: ビジュアルスクリプティング
+description: 執筆時点でわかっているHytaleのビジュアルスクリプティングシステムの紹介。
 ---
 
-# Visual Scripting
+# ビジュアルスクリプティング
 
-Hytale plans to support Visual Scripting as a method to make advanced logic and control flow accessible to a wider audience. This system will not be available at launch, but should be available shortly after launch.
+Hytaleは、高度な処理と制御フローを多くのユーザーが利用できるようにする方法として、ビジュアルスクリプティングを計画しています。 このシステムはリリース時には利用できませんが、リリース以降に利用可能になる予定です。
 
-## Overview
+## 概要
 
-Visual Scripting in Hytale is designed to function similarly to Blueprints in Unreal Engine. It allows designers to create complex behaviors through a visual interface that matches how they think about game logic, without needing to write code directly.
+Hytaleのビジュアルスクリプティングは、Unreal Engineのブループリントと同じように機能するよう設計されています。 デザイナーが直接コードを書くことなく、直感的なインターフェースを通じてゲームの複雑な挙動を作成できるように設計されています。
 
-### Key Features
+### 主な特徴
 
-* **Subset of Java functionality**: Visual Scripting can do a subset of what is possible with Java plugins
-* **Designer-friendly**: "Designers are empowered through a visual language that matches how they think about behaviors"
-* **Programmer extensible**: Programmers can extend and optimize the system by adding new visual nodes and performance-sensitive implementations
-* **Safe sharing environment**: Provides a sandboxed, safe environment for sharing logic between modders
+* **Java機能の一部**：ビジュアルスクリプティングは、Javaプラグインで実装できる一部の機能を実現できる
+* **デザイナーフレンドリー**：「デザイナーは、振る舞いを考える思考様式に合ったビジュアル言語を通じて自ら実装・調整できるようになっている。」
+* **プログラマー拡張可能**：プログラマーは、新しいビジュアルノードと性能重視の実装を提供することで、システムを拡張・最適化できます。
+* **安全な共有環境**：MOD開発者同士でロジックを共有するための、サンドボックス化された安全な環境を提供します。
 
-## Advantages Over Traditional Coding
+## 従来のコーディングに対する利点
 
-Visual Scripting makes writing custom logic more accessible by removing common hurdles found when developing in Java:
+ビジュアルスクリプティングは、Javaでの開発時によくあるハードルを無くすことで、カスタムロジックを簡単に作れるようにします。
 
-* **No complex environment setup**: No need to worry about installing the right tools or configuring development environments
-* **Syntax-free development**: Removes the need to learn and remember programming syntax
-* **Safer sharing**: Malware in visual scripting should be virtually impossible
-* **More inclusive**: Lowers the barrier to entry for non-programmers
+* **複雑な環境設定は不要**：適切なツールのインストールや開発環境の設定について心配する必要はありません。
+* **構文なしの開発**：プログラミング構文を学習する必要がなくなります。
+* **より安全な共有**：ビジュアルスクリプティングでのマルウェアの発生は事実上不可能のはずです。
+* **より多様的**: プログラマー以外の人のための参入の敷居を下げます。
 
-## Relationship with Java
+## Javaとの関係
 
-Visual Scripting and Java plugins are designed to work in tandem:
+ビジュアルスクリプティングとJava プラグインは連携して動作するように設計されています。
 
-* **Java extends Visual Scripting**: Programmers can create new visual nodes using Java
-* **Performance optimization**: While Visual Scripting may not be as optimized as Java directly, programmers can implement performance-critical logic in Java and expose it as visual nodes
-* **Best of both worlds**: Allows the majority of logic to remain in the accessible Visual Scripting environment while keeping expensive operations optimized
+* **Javaがビジュアルスクリプティングを拡張**：プログラマーはJavaを使用して新しいビジュアルノードを作成できます。
+* **パフォーマンスの最適化**：ビジュアルスクリプティングはJavaほど直接的に最適化されていませんが、プログラマーは重要なパフォーマンスの処理をJavaで実装し、それをビジュアルノードとして公開することができます。
+* **両方の利点を活かす**：大部分のロジックを扱いやすいビジュアルスクリプティング環境内に維持しつつ、処理負荷の高い操作は最適化されたままにできます。
 
-Hytale strongly recommends Visual Scripting since it is both more accessible and safer to share and download. However, staying purely in Java will still work for those who prefer it.
+Hytaleは、よりアクセスしやすく、かつ共有やダウンロードもより安全であるため、ビジュアルスクリプティングを強く推奨しています。 ですが、Javaのみで開発することも可能です。
 
-## 3D Visual Scripting
+## 3Dビジュアルスクリプト
 
-One of Hytale's unique features is bringing visual scripting directly into the 3D world:
+Hytaleのユニークな機能の1つは、ビジュアルスクリプトを3D世界に直接導入することです。
 
-* **In-world editing**: Link levers, doors, spawners, triggers, and other elements directly inside the game
-* **Adventure map creation**: Excellent for building adventure maps and encounters without leaving Hytale
-* **Similar to DOOM SnapMap**: Provides a familiar workflow for those who have used similar systems
-* **Fully integrated**: Works seamlessly with the asset and scripting stack
+* **ワールド内編集**：レバー、ドア、スポナー、トリガーなどの要素をゲーム内で直接リンクします。
+* **アドベンチャーマップ作成**：Hytaleを離れずに、アドベンチャーマップやエンカウント処理を構築するのに最適です。
+* **DOOM SnapMapとの類似**: 類似したシステムを利用したことがある人のために似たワークフローを提供します。
+* **完全な統合**: アセットとスクリプトスタックとシームレスに動作します。
 
-## No Text-Based Scripting
+## テキストスクリプトを使わない
 
-Hytale has made a deliberate decision not to include text-based scripting languages. Their reasoning:
+Hytaleは、テキストベースのスクリプト言語を含めないという意図的な決定を下しています。 その理由は以下のとおりです。
 
-* **False compromise**: Text-based scripting is often introduced to "help non-programmers" but still requires learning programming concepts
-* **Complexity increase**: Programmers end up juggling two languages where one is less powerful
-* **Still requires syntax**: Designers still need to learn syntax and programming concepts
-* **Less inclusive**: Doesn't truly solve the accessibility problem
-* **Fragmentation**: Avoids "fragmenting logic across multiple 'half-languages'"
+* **見せかけの妥協案**：テキストベースのスクリプトでの開発はしばしば「非プログラマー向け」と称して導入されますが、実際はプログラミング概念を学ぶ必要があります。
+* **複雑さの増大**：プログラマーは、能力の低い言語一つと組み合わせて二つの言語を扱うことになります。
+* **依然として構文が必要**：それでもデザイナーは構文とプログラミングの概念を学ぶ必要があります。
+* **包括性が低い**：アクセシビリティの問題を真に解決しません。
+* **断片化回避**：「複数の『中途半端な言語』にロジックを分散させる」ことを避けます。
 
-Instead, Hytale believes visual scripting is a better approach that truly makes game logic accessible to a wider audience while maintaining the power and flexibility needed
+代わりに、Hytaleはビジュアルスクリプティングこそが、ゲームロジックをより幅広いユーザーが利用できるようにしながら、必要な能力と柔軟性を維持する最良のアプローチだと考えています。
diff --git a/content/docs/ja-JP/established-information/server/interface/inputs.mdx b/content/docs/ja-JP/established-information/server/interface/inputs.mdx
index b6b3ff3b..9a6a5f17 100644
--- a/content/docs/ja-JP/established-information/server/interface/inputs.mdx
+++ b/content/docs/ja-JP/established-information/server/interface/inputs.mdx
@@ -1,16 +1,16 @@
 ---
-title: Inputs
-description: Information about input methods supported in Hytale.
+title: 入力操作
+description: Hytaleでサポートされている入力方法に関する情報。
 ---
 
-Hytale is designed to support a variety of input methods to accommodate different player preferences and platforms.
+Hytaleは、さまざまなプレイヤーの好みやプラットフォームに対応するために、多くの入力操作をサポートするように設計されています。
 
-## Interaction System
+## インタラクションシステム
 
-Hytale features a robust interaction system that allows plugins to customize how keybinds are interpreted and what actions they trigger. This system is data-driven, enabling modders to create complex interactions through assets.
+Hytaleは堅牢なインタラクションシステムを備えており、プラグインによってキーコンフィグの設定やトリガーされるアクションをカスタマイズできます。 このシステムはデータ駆動型であるため、MOD開発者はアセットを通じて複雑なインタラクションを作成できます。
 
-Modders can define custom keybinds for various actions, such as using abilities or interacting with objects in the game world. The interaction system is designed to be powerful, though it may require some effort to manage the complexity of the assets involved.
+MOD開発者は、能力の使用やゲーム内のオブジェクトとのインタラクションなど、様々なアクションにキーコンフィグを設定できます。 インタラクションシステムは強力な設計となっていますが、関連するアセットの複雑さを管理するには少し努力が必要になる場合があります。
 
-> You can use your own interactions to use keybinds for whatever you want. Interaction system is very powerful but we still need to work on its usability as the assets can become quite complex and hard to handle
+> 独自のインタラクションを使用して、自由にキーコンフィグを使うことができます。 インタラクションシステムは非常に強力ですが、アセットがかなり複雑になり、扱いにくくなる可能性があるため、まだまだ改善する余地があります。
 
 \- [slikey](https://discord.com/channels/523059903812599811/1428794280868184064/1441291391065129103)
diff --git a/content/docs/ja-JP/established-information/server/interface/ui-customization.mdx b/content/docs/ja-JP/established-information/server/interface/ui-customization.mdx
index d2acbd6b..0841ca20 100644
--- a/content/docs/ja-JP/established-information/server/interface/ui-customization.mdx
+++ b/content/docs/ja-JP/established-information/server/interface/ui-customization.mdx
@@ -1,80 +1,77 @@
 ---
-title: UI Customization
-description: Information about UI customization in Hytale.
+title: |
+  UIカスタマイズ
+description: HytaleのUIカスタマイズに関する情報。
 ---
 
-UI can be customized via **server-side** modding. Many of the UI pages shown to players are available to be modified by server owners through mods.
+UIは**サーバーサイドのMOD**によってカスタマイズできます。 プレイヤーに表示される多くのUIページは、サーバー所有者がMODを通じて変更できるようになっています。
 
-## UI Customization in Hytale
+## HytaleのUIカスタマイズ
 
-Hytale provides extensive UI customization capabilities through server-side modding, allowing server owners to modify many of the UI pages that players interact with.
+Hytaleは、サーバーサイドのMODを通じてUIカスタマイズの幅広い機能を提供しており、サーバー所有者はプレイヤーが操作する多くのUI ページを変更できます。
 
-### Control Flow
+### 制御フロー
 
-The UI system in Hytale follows a specific control flow pattern:
+HytaleのUIシステムは、特定の制御フロー パターンに従います。
 
-1. Server sends UI data to the client
-2. Client renders the UI
-3. User interacts with the UI (e.g., pressing a button)
-4. Client sends the interaction event to the server
-5. Server executes the callback logic for the event
+1. サーバーはクライアントにUIデータを送信します
+2. クライアントがUIをレンダリングする
+3. ユーザーがUIを操作する（例：ボタンを押す）
+4. クライアントはインタラクションイベントをサーバーに送信する
+5. サーバーはイベントのコールバック処理を実行します
 
-This architecture means:
+このアーキテクチャは次のことを意味します。
 
-* The client is responsible for rendering UI and sending user interactions to the server
-* The server handles all the actual logic behind user interactions
+* クライアントはUIをレンダリングし、ユーザーインタラクションをサーバーに送信する役割を担う。
+* サーバーは、ユーザーの操作に関するすべての実際の処理を担います。
 
-<Callout type="warning" title="Possible Performance Implications">
+<Callout type="warning" title="パフォーマンスへの影響の可能性">
   <span>
-    Because the server processes all UI logic, there is an inherent latency
-    impact on UI responsiveness. Button clicks and other interactions must
-    travel to the server before taking effect, meaning network ping directly
-    affects UI responsiveness.
+    すべてのUI動作はサーバーで処理されるため、UIの反応にはラグが生じます。 ボタンのクリックやその他の操作は、反映されるより先にサーバーへ送信される必要があるため、ネットワークの遅延（ping）がUIの反応速度に直接影響します。
   </span>
 
   <span>
-    Additionally, since client-side modding is not supported, no modded values
-    persist on the client.
+    さらに、クライアント側のMOD開発はサポートされていないため、MODの数値はクライアント上に保持されません。
   </span>
 </Callout>
 
-### UI Layout Assets
+### UIレイアウトアセット
 
-Hytale's UI customization system works through the following structure:
+HytaleのUIカスタマイズ システムは、次の構造で機能します。
 
-* **UI Layout**: Sent to the client as an asset
-* **UI Behavior**: Defined in Java code
-* **Custom Layouts**: Enables creation of bespoke UI layouts rather than repurposing existing ones (unlike inventory menu modifications in Minecraft)
+* **UIレイアウト**：アセットとしてクライアントに送信
+* **UI動作**：Javaのコードで定義
+* **カスタム レイアウト**：既存のレイアウトを再利用するのではなく、オリジナルでUIレイアウトを作成できます（Minecraftのインベントリメニューの変更とは異なります）
 
-### UI Framework Implementations
+### UIフレームワークの実装
 
-Hytale currently supports multiple UI implementations, with plans to consolidate on NoesisGUI:
+Hytaleは現在複数のUI実装をサポートしており、NoesisGUIに統合する予定です。
 
-#### Legacy Implementation
+#### 従来の実装
 
-* Serves as an example of server modding capabilities
-* Uses a combination of in-game elements, UI Markup Assets, and Java mod code
-* Utilizes a legacy custom markup language
-* Will be deprecated in favor of NoesisGUI
+* サーバーでのMODの機能の一例として機能します。
+* ゲーム内要素、UIマークアップアセット、JavaのMODコードを組み合わせて使用​​します
+* 従来の自作マークアップ言語を利用する
+* NoesisGUIに置き換えられるため廃止される予定です
 
-#### NoesisGUI (Primary Framework)
+#### NoesisGUI (主要なフレームワーク)
 
-* Uses XAML Markup Language for UI definition
-* Supports multiple languages for internationalization
-* Runs on C# bindings on the client side (not C++)
-* Represents the future direction of Hytale's UI system
+* UI定義にはXAMLマークアップ言語を使用する
+* 国際化のために複数の言語をサポート
+* クライアント側ではC#バインディングで実行されます（C++ではありません）
+* HytaleのUIシステムの今後の方向性を示しています。
 
-#### Third Framework
+#### 第三のフレームワーク
 
-* Currently being phased out
-* Will be replaced by NoesisGUI as part of the consolidation effort
+* 現在段階的に廃止中
+* 統合作業の一環としてNoesisGUIに置き換えられます
 
-### Performance Considerations
+### パフォーマンスに関する考慮事項
 
-Due to the server-side nature of UI processing, there are inherent performance characteristics to consider:
+UI処理がサーバー側で行われる性質上、考慮すべき固有のパフォーマンス特性があります。
 
-* **Latency Impact**: Button clicks and UI interactions must travel to the server before taking effect, meaning network ping directly affects UI responsiveness
-* **No Client Persistence**: Since client-side modding is not supported, no modded values persist on the client
-* **Optimized Architecture**: Hytale's system is designed to minimize latency through efficient communication protocols and optimized server performance, ensuring smooth interactions despite server-side processing requirements
+* **遅延の影響**：ボタンのクリックやUIの操作は、効果を発揮するより先にサーバーに送信される必要があるため、ネットワークのpingはUIの応答性に直接影響します。
+* **クライアントでの保存無し**: クライアント側のMod開発はサポートされていないため、Modによる値はクライアント側に保持されません。
+* **最適化されたアーキテクチャ**：Hytaleのシステムは、効率的な通信プロトコルと最適化されたサーバーパフォーマンスによって遅延を最小限に抑えるよう設計されており、サーバー側での処理が必要であってもスムーズな操作を実現します。
 
-The architecture prioritizes security and consistency by centralizing UI logic on the server while maintaining responsive user experiences
+このアーキテクチャは、UIロジックをサーバー側に集約することでセキュリティと一貫性を優先しつつ、ユーザーにとって応答性の高い操作体験を維持します。
diff --git a/content/docs/ja-JP/established-information/server/server-first-dev.mdx b/content/docs/ja-JP/established-information/server/server-first-dev.mdx
index 1ed97a61..2d70cd66 100644
--- a/content/docs/ja-JP/established-information/server/server-first-dev.mdx
+++ b/content/docs/ja-JP/established-information/server/server-first-dev.mdx
@@ -1,29 +1,28 @@
 ---
-title: Server-First Development
-description: Information regarding what Server-First Development means, and more.
+title: サーバーファースト開発
+description: サーバーファースト開発とは何を意味するか、などに関する情報
 ---
 
-Hytale is being developed with a "server-first" approach. This means that the server is considered the authoritative source of game state and logic, while the client primarily handles rendering and user input.
+Hytale は「サーバーファースト」手法で開発されています。 これは、サーバーがゲームの状態やロジックにおける信頼できる情報源として扱われ、クライアントは主に描画とユーザー入力の処理を担当することを意味します。
 
-## What does "Server-First" mean?
+## 「サーバーファースト」とはどういう意味ですか？
 
-In a server-first architecture, the server is responsible for managing the game world, enforcing rules, and processing player actions. The client connects to the server to receive updates about the game state and to send player inputs. This approach helps ensure consistency and fairness in multiplayer environments, as the server has control over the game logic.
+サーバーファーストアーキテクチャでは、サーバーがゲーム世界の管理、ルールの適用、およびプレイヤーの行動の処理を担当します。 クライアントはサーバーに接続し、ゲームの状態とプレイヤーの入力を送信します。 この手法は、サーバーがゲーム処理を制御するため、マルチプレイヤー環境における一貫性と公平性を確保するのに役立ちます。
 
-## Benefits of Server-First Development
+## サーバーファースト開発のメリット
 
-* **Consistency**: Since the server is the authoritative source, all players experience the same game state, reducing discrepancies and cheating.
-* **Scalability**: Server-first architectures can be more easily scaled to accommodate large numbers
-  of players, as the server can manage resources and distribute load effectively.
-* **Security**: By centralizing game logic on the server, it becomes more difficult for players to manipulate the game state unfairly.
-* **Easier Updates**: Updates and changes can be made on the server side without requiring players to download new client versions.
-* **Only One Version**: There won't be a version selector for the Hytale Client, meaning that server owners do not need to support multiple versions and can rely on everyone being on the latest client. This will help both server owners and modders.
+* **一貫性**：サーバーは信頼できる情報源であるため、すべてのプレイヤーが同じゲーム状態を体験でき、矛盾やチート行為を減らすことができます。
+* **スケーラビリティ**：サーバーファーストアーキテクチャは、サーバーが情報源を管理し、負荷を効果的に分散できるため、大量のプレイヤーに対応するよう容易にスケールすることができます。
+* **セキュリティ**：ゲーム処理をサーバーに集中させることで、プレイヤーがゲームの状態を不当に操作することが難しくなります。
+* **より簡単なアップデート**：プレイヤーが新しいバージョンをダウンロードする必要なく、サーバー側でアップデートと変更を行うことができます。
+* **単一バージョン**：Hytaleクライアントにはバージョンの選択がないため、サーバー所有者は複数のバージョンをサポートする必要がなく、全員が最新のクライアントを前提にできます。 これはサーバー所有者とMOD開発者の両方にとって有益です。
 
-## Implications for Modding
+## MOD開発への影響
 
-Modders will primarily interact with the server-side components of Hytale. This means that mods will often focus on altering game logic, rules, and behaviors that are managed by the server. Client-side modifications are not allowed (as of the information given right now).
+MOD開発者は、主にHytaleのサーバーコンポーネントとやり取りを行います。 これは、MOD開発者がサーバーによって管理されるゲーム処理、ルール、および動作の変更に焦点を当てることを意味します。 クライアント側の改変は許可されていません（現時点での情報）
 
-Overall, the server-first approach in Hytale aims to create a robust and fair multiplayer experience while providing modders with powerful tools to customize and enhance the game.
+全体として、Hytaleにおけるサーバーファースト手法は、堅牢で公正なマルチプレイヤー体験を実現すると同時に、MOD開発者がゲームをカスタマイズし拡張するための強力なツールを提供することを目的としています。
 
-## Conclusion
+## 結論
 
-The server-first development model is a key aspect of Hytale's architecture, ensuring a consistent and secure multiplayer experience. Modders should focus on server-side modifications to fully leverage the capabilities of this approach and create engaging content for players.
+サーバーファースト開発モデルは、Hytaleのアーキテクチャの重要な側面であり、一貫性とセキュリティに優れたマルチプレイヤー体験を保証します。 MOD開発者は、この手法の機能を最大限に活用し、プレイヤーに魅力的なコンテンツを提供するために、サーバー側の改変に集中すべきです。
diff --git a/content/docs/ja-JP/guides/ecs/entity-component-system.mdx b/content/docs/ja-JP/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/ja-JP/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/ja-JP/guides/ecs/example-ecs-plugin.mdx b/content/docs/ja-JP/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/ja-JP/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/ja-JP/guides/ecs/hytale-ecs-theory.mdx b/content/docs/ja-JP/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/ja-JP/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/ja-JP/guides/ecs/systems.mdx b/content/docs/ja-JP/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/ja-JP/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/ja-JP/guides/java-basics/00-introduction.mdx b/content/docs/ja-JP/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/ja-JP/guides/java-basics/00-introduction.mdx
+++ b/content/docs/ja-JP/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/ja-JP/guides/java-basics/06-methods-functions.mdx b/content/docs/ja-JP/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/ja-JP/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/ja-JP/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/ja-JP/guides/learning-to-learn.mdx b/content/docs/ja-JP/guides/learning-to-learn.mdx
index 567e514e..ba0f9c16 100644
--- a/content/docs/ja-JP/guides/learning-to-learn.mdx
+++ b/content/docs/ja-JP/guides/learning-to-learn.mdx
@@ -1,37 +1,37 @@
 ---
-title: Learning to Learn
-description: A guide to help you become a better learner and adapt to new information effectively.
-icon: CircleQuestionMark
+title: 学習方法を学ぶ
+description: 効率的に学習し、新しい情報に適応できるようになるためのガイド
+icon: ""
 ---
 
-## Why learn to code? We have visual scripting!
+## なぜプログラミングを学ばないといけないの？ ビジュアルスクリプトがあるじゃない！
 
-Yes we do, and honestly you should try that out. Visual scripting is a great addition to Hytale and we know it'll be powerful, but nothing beats the ability of being able to read and write Java code, with the ability to build even more powerful mods and plugins.
+はい、一度はビジュアルスクリプトを試してみるべきだと思います。 Hytale のビジュアルスクリプトは強力で素晴らしい機能です。しかし、Java のコードを読み書きできることで、より強力なModやプラグインを開発できます。 Mod開発において Java のプログラミング能力に勝る物はありません。
 
-<Callout type="info" title="Visual Scripting vs Coding">
-  Visual scripting is great for beginners and for simple tasks, but coding allows for more complex and efficient solutions. Learning to code opens up a wider range of possibilities for modding Hytale.
+<Callout type="" title="ビジュアルスクリプト vs プログラミング">
+  ビジュアルスクリプトは初心者や単純なタスクには最適ですが、プログラミングはより複雑な問題に効率的に対応できます。 プログラミングを学ぶことで、Hytale での Mod 開発の可能性が広がります。
 
-  We will have guides on visual scripting when Hytale releases from Day 1.
+  Hytale がリリースされたら、即座にビジュアルスクリプトのガイドを用意する予定です。
 </Callout>
 
-## Should everyone trying to mod Hytale learn how to code?
+## Hytale の Mod 開発をしようとする人は全員プログラミングを学ぶべき？
 
-No one should feel like they HAVE to learn to code to make stuff in Hytale. Simon and his team have validated this time and time again with their strives in graph editors and visual scripting. You can change mob behavior, world generation, etc. all with just these tools.
+Hytale でものを作るのにプログラミングを必ず学ばなければならない、ということではありません。 Simon と彼のチームは、グラフ エディターとビジュアルスクリプトの取り組みを通じて、これを何度も検証してきました。 これらのツールだけで、Mobの行動やワールド生成などを変えることができます。
 
-But if you're looking to build more complex things (from utilities to entirely custom server software) that could be used by large scale server networks and big names, you'll want to learn how to code. And that's where this guide comes in...
+しかし、大規模なサーバーネットワークや有名サーバーで利用出来るような、より複雑なもの (便利ツールから完全なカスタムサーバーソフトまで) を作りたい場合は、プログラミングを学ぶべきでしょう。 そこでこのガイドが役に立ちます。
 
-## Okay, I'm interested. What's to come?
+## プログラミングに興味がある。 何をすれば良い？
 
-Over the course of these next several lessons you'll learn the basics of coding, how to read documentation, and how to find resources to help you learn more on your own.
+次のいくつかのレッスンでは、プログラミングのやり方・ドキュメントの読み方・自分で学ぶのに必要なリソースの見つけ方を学びます。
 
-The guides themselves will take a very big "bird's-eye view" approach to things and provide links to resources to do the actual coding. This is done because, quite frankly, enough resources exist on how to learn this stuff, it's just the act of finding the right stuff on Google that can be hard. Learning to be able to code without guidance is the goal. The Hytale Modding community is always there to help you, but to become a truly well rounded developer, you'll have to pick up a lot of this stuff just by reading from resources.
+このガイドは、非常に大きな鳥瞰的なアプローチをとり、実際にプログラミングを行うためのリンクを提供します。 これは、率直に言うと、世界には学習するのに必要なリソースは十分にあるものの、Google で正しい情報を見つけることが非常に難しいからです。 ガイダンス無しにプログラミングできるようになることが目標です。 Hytale Modding コミュニティは常にあなたを助けようとしますが、本当に良い開発者になるためには、リソース (ドキュメントやコードなど) を読むだけで多くのことを習得する必要があります。
 
-<Callout type="info" title="Finding Resources">
-  We have created a small Java Basics series to help you get started with the language itself, but beyond that, you'll be expected to find your own resources to learn more. We recommend sites like [w3schools](https://www.w3schools.com/java/) and [GeeksforGeeks](https://www.geeksforgeeks.org/java/) as great starting points.
+<Callout type="" title="リソースを見つける">
+  私達は、Java を使い始めるために役立つ小さな Java の基礎シリーズを作成しました。しかし、それ以上のことをするためには、自分で学習するためのリソースを見つけることが求められます。 [w3schools](https://www.w3schools.com/java/) や [GeeksforGeeks](https://www.geeksforgeeks.org/java/) のようなサイトを素晴らしい出発点としておすすめします。 (訳注: これらのサイトは英語のみです。日本語なら [とほほのJava入門](https://www.tohoho-web.com/java/) や [JavaDrive](https://www.javadrive.jp/) 、書籍なら [プロになるJava](https://gihyo.jp/book/2022/978-4-297-12685-8) を翻訳者は個人的におすすめします。)
 </Callout>
 
-Our goal is to teach you how to Mod Hytale, and that will always be our goal. This is the reason we can't teach you everything about Java or programming in general. Instead, we want to give you the tools to be able to learn on your own, so you can continue to grow as a developer even after you've completed our guides.
+私達の目標は常に「Hytale の Mod 開発についてを教える」ことであり続けます。 これが、Java やプログラミングの一般的なことについて私達が教えることができない理由です。 代わりに、私たちはあなたが自身で学ぶことができるツールを提供したいと思います。 このガイドを学習し終えても開発者として成長し続けられるからです。
 
-## Any closing thoughts?
+## 最後に一言
 
-Remember, learning to code is hard. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come. Happy coding!
+覚えておいてください。プログラミングを学ぶのは難しいです。 学習の途中で何度も躓き挫折するでしょう。しかし、あなたがそこから立ち上がれると私達は信じています。 しなやかさを保ち、あなたが素晴らしい物を作れると信じてください。私があなたの成功を約束します。 楽しいプログラミングを！
diff --git a/content/docs/ja-JP/guides/plugin/block-components.mdx b/content/docs/ja-JP/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/ja-JP/guides/plugin/browsing-serverjar.mdx b/content/docs/ja-JP/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/ja-JP/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/ja-JP/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/ja-JP/guides/plugin/build-and-test.mdx b/content/docs/ja-JP/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/ja-JP/guides/plugin/chat-formatting.mdx b/content/docs/ja-JP/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/ja-JP/guides/plugin/chat-formatting.mdx
+++ b/content/docs/ja-JP/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/ja-JP/guides/plugin/client-inputs-reference.mdx b/content/docs/ja-JP/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/ja-JP/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/ja-JP/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/ja-JP/guides/plugin/creating-block.mdx b/content/docs/ja-JP/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/ja-JP/guides/plugin/creating-block.mdx
+++ b/content/docs/ja-JP/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/ja-JP/guides/plugin/creating-commands.mdx b/content/docs/ja-JP/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/ja-JP/guides/plugin/creating-commands.mdx
+++ b/content/docs/ja-JP/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/ja-JP/guides/plugin/creating-configuration-file.mdx b/content/docs/ja-JP/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/ja-JP/guides/plugin/creating-events.mdx b/content/docs/ja-JP/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/ja-JP/guides/plugin/creating-events.mdx
+++ b/content/docs/ja-JP/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/ja-JP/guides/plugin/customizing-camera-controls.mdx b/content/docs/ja-JP/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/ja-JP/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/ja-JP/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/ja-JP/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/ja-JP/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/ja-JP/guides/plugin/instances.mdx b/content/docs/ja-JP/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/ja-JP/guides/plugin/inventory-management.mdx b/content/docs/ja-JP/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/ja-JP/guides/plugin/inventory-management.mdx
+++ b/content/docs/ja-JP/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/ja-JP/guides/plugin/item-interaction.mdx b/content/docs/ja-JP/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/ja-JP/guides/plugin/listening-to-packets.mdx b/content/docs/ja-JP/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/ja-JP/guides/plugin/logging.mdx b/content/docs/ja-JP/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/ja-JP/guides/plugin/player-death-event.mdx b/content/docs/ja-JP/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/ja-JP/guides/plugin/player-input-guide.mdx b/content/docs/ja-JP/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/ja-JP/guides/plugin/player-input-guide.mdx
+++ b/content/docs/ja-JP/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/ja-JP/guides/plugin/player-stats.mdx b/content/docs/ja-JP/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/ja-JP/guides/plugin/setting-up-env.mdx b/content/docs/ja-JP/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/ja-JP/guides/plugin/setting-up-env.mdx
+++ b/content/docs/ja-JP/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/ja-JP/guides/plugin/spawning-entities.mdx b/content/docs/ja-JP/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/ja-JP/guides/plugin/spawning-entities.mdx
+++ b/content/docs/ja-JP/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/ja-JP/guides/plugin/spawning-npcs.mdx b/content/docs/ja-JP/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/ja-JP/guides/plugin/store-persistant-data.mdx b/content/docs/ja-JP/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/ja-JP/guides/plugin/teleporting-players.mdx b/content/docs/ja-JP/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/ja-JP/guides/plugin/teleporting-players.mdx
+++ b/content/docs/ja-JP/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/ja-JP/guides/plugin/text-hologram.mdx b/content/docs/ja-JP/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/ja-JP/guides/plugin/ui.mdx b/content/docs/ja-JP/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/ja-JP/guides/plugin/world-gen.mdx b/content/docs/ja-JP/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/ja-JP/guides/plugin/world-gen.mdx
+++ b/content/docs/ja-JP/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/ja-JP/guides/prefabs.mdx b/content/docs/ja-JP/guides/prefabs.mdx
index c258f63b..676ebd66 100644
--- a/content/docs/ja-JP/guides/prefabs.mdx
+++ b/content/docs/ja-JP/guides/prefabs.mdx
@@ -1,92 +1,94 @@
 ---
-title: Prefabs
-description: Documentation about Prefabs in Hytale.
-icon: Box
+title: プレハブ
+description: Hytaleのプレハブに関するドキュメント
+icon: ""
 authors:
-  - name: Ben Cressman
-    link: https://bencres.dev
+  - name: ""
+    url: ""
 ---
 
-# Introduction
+# はじめに
 
-Prefabs are Hytale's way of creating reusable structures.
+プレハブ (Prefabs) は Hytale における再利用可能な構造を作成するための方法です。
 
-There are a few fundamental concepts to understand about prefabs:
+プレハブについて理解すべきいくつかの基本的な概念があります。
 
-- Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- ユーザーは、プレハブ編集ワールドを介してプレハブを操作します。
+- プレハブはゲーム世界における物理的な構造であり、JSON ファイルとして保存されます。
 
-## How to Create a Prefab
+## プレハブの作り方
 
-Be sure to check the Known Issues section at the end of this guide if you encounter any problems.
+問題が発生した場合は、必ずこのガイドの最後にある「既知の問題」セクションを確認してください。
 
-1. `/editprefab new <world name>` to create a new prefab editing world: `/editprefab new my_prefab_world`
-   - Note that `my_prefab` is the name of the _world_, not the prefab itself. Worlds can contain multiple prefabs.
-2. Build whatever you want in the prefab editing world.
-3. Use the selection brush to select the area you want to save as a prefab.
-4. `/prefab save` to save the structure as a prefab.
-5. `/editprefab exit` to exit the prefab editing world.
-6. Using the Paste brush, press 'e' on your keyboard to select the prefab you just created. It will be in the "server" dropdown, which can be selected from the top right of the menu.
-   - You can also select it with `/prefab list` and selecting the prefab you just created.
+1. `/editprefab new <world name>` で新しいプレハブ編集ワールドを作成します: `/editprefab new my_prefab_world`
+   - `my_prefab` はプレハブ自体ではなく _ワールド_ の名前であることに注意してください。 ワールドは複数のプレハブを含めることができます。
+2. プレハブ編集ワールドで好きなものを作ります。
+3. 選択ツール (Selection Tool) を使用して、プレハブとして保存したい領域を選択します。
+4. `/prefab save` で構造をプレハブとして保存します。
+5. `/editprefab exit` でプレハブ編集ワールドを終了します。
+6. 貼り付けツール (Paste Tool) を手に持った状態で、キーボードの 'e' キーを押すとプレハブ一覧が表示されます。 メニューの左上にあるドロップダウン (検索窓の左の"ASSETS"と表示されている場所) から「サーバー (SERVER)」を選択し、その後作成したプレハブを選択します。
+   - `/prefab list` で作成したプレハブを選択することもできます。
 
-There is a lot more that you can do with prefabs; this is just the basic flow. Keep reading for more information.
+プレハブでできることはもっとたくさんあります。これは基本的な流れです。 詳細については続きを読んでください。
 
-## Commands
+## コマンド
 
-There are two main commands for prefabs, `/prefab` and `/editprefab`.
+プレハブでは、主に `/prefab` と `/editprefab` の2つのコマンドを使います。
 
-This list does not cover the various options for each command. You can use the `--help` flag at the end of any command to see the available options, e.g. `/prefab save --help`, or use `/help` in game and find the `prefab` and `editprefab` commands.
+この一覧では、各コマンドの詳細なオプションについては説明しません。 コマンドの最後に `--help` フラグを追加することで利用可能なオプションの一覧を表示できます。 例: `/prefab save --help`\
+また、 `/help` コマンドを使用してコマンドのヘルプ画面を表示し、 `prefab` や `editprefab` の項目から詳細を確認することもできます。
 
-### `/prefab`
+###
 
-This command allows the user to interact with an existing prefab's file.
+このコマンドを使うと、既存のプレハブファイルを操作することができます。
 
-Subcommands:
+サブコマンド:
 
-- `save`
-  - Saves the prefab to the file system.
-- `load`
-  - Loads the prefab into the game.
-- `delete`
-  - Deletes the prefab from the file system.
-- `list`
-  - Lists all prefabs in the file system.
+-
+  - プレハブをファイルシステムに保存します。
+-
+  - プレハブをゲームにロードします。
+-
+  - プレハブをファイルシステムから削除します。
+-
+  - ファイルシステム内のプレハブの一覧を表示します。
 
-### `/editprefab`
+###
 
-The `/editprefab` command is used to create or edit the physical structure in the game the prefab is holding.
+`/editprefab` コマンドは、プレハブが持っているゲーム内の物理的な構造を作成または編集するために使用されます。\
+(訳注: 翻訳時点で、 `/editprefab` コマンドを使うには OP 権限が必要です。シングルプレイの場合、 `/op` コマンドで OP 権限を獲得可能です。)
 
-Subcommands:
+サブコマンド:
 
-- `exit`
-  - Exits the current prefab editing world.
-- `load`
-  - Creates a new prefab editing world to paste an existing prefab into.
-- `new`
-  - Creates a new prefab editing world to create a new prefab from scratch.
-- `select`
-  - Selects the area of the prefab the user is looking at (within 200 blocks).
-- `save`
-  - Saves the current prefab using the existing area, or the currently selected area.
-- `saveui`
-  - Opens the save UI for the current world, allowing the user to interact with all prefabs that are in the world.
-- `kill`
-  - Despawn all entities in the currently selected prefab.
-- `saveas`
-  - Save the selected prefab into a new file.
-- `setbox`
-  - Set the bounding box of the currently selected prefab.
-- `info`
-  - General information about the currently selected prefab.
-- `tp`
-  - Opens the teleport UI to teleport to a prefab in the current editing world.
-- `modified`
-  - Lists all modified prefabs with unsaved changes in the current editing world.
+-
+  - 現在のプレハブ編集ワールドを終了します。
+-
+  - 新しいプレハブ編集ワールドを作成し、そこに既存のプレハブを貼り付けます。
+-
+  - 新しいプレハブを0から作成するために、プレハブ編集ワールドを作成します。
+-
+  - プレイヤーが見ているプレハブ領域を選択します (200ブロック以内) 。
+-
+  - 既存の領域または現在選択している領域を使って現在のプレハブを保存します。
+-
+  - 現在のワールドのセーブUIを開き、ワールド内の全てのプレハブを操作できるようにします。
+-
+  - 現在選択されているプレハブ内のすべてのエンティティをデスポーン (削除) します。
+-
+  - 選択したプレハブを新しいファイルに保存します。
+-
+  - 現在選択されているプレハブのバウンディングボックスを設定します。
+-
+  - 現在選択されているプレハブの一般的な情報を表示します。
+-
+  - 現在の編集ワールド内のプレハブにテレポートするためのテレポートUIを開きます。
+-
+  - 現在の編集ワールド内の、保存されていない変更を含むプレハブの一覧が表示されます。
 
-# Known Issues
+# 既知の問題
 
-- After saving edits to an existing prefab, the prefab does not reflect the changes in the game.
-  - Workaround: exit and re-enter the world.
-- When pasting a prefab, the prefab is not always shown accurately.
-  - Workaround: hit 't' on your keyboard to toggle the material being shown; usually at least one view is accurate.
-- `/prefab delete` errors with `Assert not in thread`.
+- 既存のプレハブへの編集を保存した後、プレハブがゲームに反映されません。
+  - 回避策: ワールドから退出し、再度入り直します。
+- プレハブを貼り付ける場合、プレハブが正しく表示されない場合があります。
+  - 回避策:キーボードの「t」を押すと、表示されるマテリアルを切り替えることができます。通常、少なくとも1つの表示が正確です。
+- `/prefab delete` コマンドが `Assert not in thread.` エラーを出す
diff --git a/content/docs/ja-JP/index.mdx b/content/docs/ja-JP/index.mdx
index e09ace85..369fe19a 100644
--- a/content/docs/ja-JP/index.mdx
+++ b/content/docs/ja-JP/index.mdx
@@ -1,19 +1,16 @@
 ---
-title: Introduction
-description: Necessary knowledge for modding Hytale.
+title: はじめに
+description: HytaleでのMod開発に必要な知識
 ---
 
-Hytale is a voxel-based sandbox RPG game by **Hypixel Studios**, as described on the [Hytale website](https://hytale.com/):
+Hytale は、[Hytale website](https://hytale.com/)に記載されているように、**Hypixel Studios** による ボクセルベースの サンドボックスRPG ゲームです。
 
-> Set out on an adventure built for both creation and play. Hytale blends the freedom
-> of a sandbox with the momentum of an RPG: explore a procedurally generated world full
-> of dungeons, secrets, and a variety of creatures, then shape it block by block.
+> 創造と遊びの両方のために構築された冒険に出かけてください。 Hytale はサンドボックスの自由さとRPGの勢いを融合させています。ダンジョン・秘密・多様な生物で満たされ、手続き的に生成され、ブロックにより構成された世界を探検しましょう。
 
-Hytale has been built from the ground up with modding and user-generated content in mind.
-The goal of **Hytale Modding** is to provide an excellent resource such that anybody
-is able to mod Hytale for themselves, regardless of skill level or specialization.
+Hytale は、Mod開発やユーザー生成コンテンツを念頭に置いて構築されています。
+**Hytale Modding**の目標は、誰もがスキルレベルや専門性に関わらずHytaleを自分自身で改造できるようなリソースを提供することです。
 
-It is important to note that modding Hytale is not restricted to programming plugins.
-Programming, visual scripting, texturing, 3D modelling, modifying assets, etc. are all modding.
+HytaleのMod開発は、プログラミングによって開発したプラグインに限られないというのは重要な点です。
+プログラミング、ビジュアルスクリプティング、テクスチャ、3Dモデリング、アセットの改変など、全てがMod開発です。
 
-<u>In Hytale, anyone can be a modder.</u>
+<u>Hytale では、誰もがModderになれます。</u>
diff --git a/content/docs/ja-JP/official-documentation/npc-doc.mdx b/content/docs/ja-JP/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/ja-JP/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/ja-JP/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/ja-JP/publishing/builtbybit.mdx b/content/docs/ja-JP/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/ja-JP/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/ja-JP/publishing/index.mdx b/content/docs/ja-JP/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/ja-JP/publishing/index.mdx
+++ b/content/docs/ja-JP/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/ja-JP/quick-start.mdx b/content/docs/ja-JP/quick-start.mdx
index 18ab3e2d..a0f4122a 100644
--- a/content/docs/ja-JP/quick-start.mdx
+++ b/content/docs/ja-JP/quick-start.mdx
@@ -1,11 +1,11 @@
 ---
-title: Quick Start
-description: Setting up a standard Hytale project.
+title: クイックスタート
+description: 標準的な Hytale プロジェクトの構築。
 ---
 
-Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+Hytale Mod開発ドキュメントへようこそ！ ここでは、Hytale用のModの作成について知っておくべきことをすべて見つけることができます。
 
-* [Java Basics](./guides/java-basics/00-introduction)
-* [Setting up your dev environment](./guides/plugin/setting-up-env)
-* [Entity Component System (ECS)](./guides/ecs)
-* [Publishing your mod](./guides/publishing)
+* [Java の基本](./guides/java-basics/00-introduction)
+* [開発環境の構築](./guides/plugin/setting-up-env)
+* [エンティティコンポーネントシステム (ECS)](./guides/ecs)
+* [Modの公開](./guides/publishing)
diff --git a/content/docs/ja-JP/server/entities.mdx b/content/docs/ja-JP/server/entities.mdx
index 872f3fa4..96a78039 100644
--- a/content/docs/ja-JP/server/entities.mdx
+++ b/content/docs/ja-JP/server/entities.mdx
@@ -1,441 +1,441 @@
 ---
-title: Entities
-description: List of all Entities in Hytale
+title: エンティティ
+description: Hytale 内のすべてのエンティティの一覧
 icon: List
 full: true
 ---
 
-This page contains a list of all Entities available to be used as a key in the AssetMap.
+このページには、AssetMap 内のキーとして使用できるすべてのエンティティのリストが含まれています。
 
-- Antelope
-- Archaeopteryx
-- Armadillo
-- Arrow_Crossbow_Signature
-- Arrow_Crude
-- Arrow_Fire
-- Arrow_Frost
-- Arrow_Iron
-- Arrow_Ricochet
-- Arrow_Ricochet_Signature
-- Arrow_Shortbow_Signature
-- Arrow_Vamp
-- Arrow_Vamp_Signature
-- Axe_Bone
-- Axe_Stone_Trork
-- Bat
-- Bat_Ice
-- Bear_Grizzly
-- Bear_Polar
-- Bison
-- Bison_Calf
-- Bluebird
-- Bluegill
-- Boar
-- Boar_Piglet
-- Boat
-- Bomb
-- Bomb_Fire_Goblin
-- Bomb_Fire_Goblin_Dud
-- Bomb_Large_Fire_Goblin
-- Bomb_Popberry
-- Bomb_Potion_Poison
-- Boy_Trail
-- Bramblekin
-- Bramblekin_Shaman
-- Bullet_Blunderbuss
-- Bunny
-- Cactee
-- Cactee_Spike
-- Calf
-- Camel
-- Camel_Calf
-- Cat
-- Catfish
-- Chick
-- Chick_Desert
-- Chicken
-- Chicken_Desert
-- Chicken_Undead
-- Clownfish
-- Corgi
-- Cow
-- Cow_Undead
-- Crab
-- Crawler_Void
-- Crocodile
-- Crossbow_Turret
-- Crossbow_Turret_Item_Projectile
-- Crow
-- Dagger_Adamantite
-- Dagger_Bone
-- Dagger_Bronze
-- Dagger_Bronze_Ancient
-- Dagger_Cobalt
-- Dagger_Copper
-- Dagger_Crude
-- Dagger_Doomed
-- Dagger_Fang_Doomed
-- Dagger_Iron
-- Dagger_Mithril
-- Dagger_Onyxium
-- Dagger_Stone_Trork
-- Dagger_Thorium
-- Debug
-- Deer_Doe
-- Deployable_Fire_Trap
-- Deployable_Fire_Trap_Preview
-- Dog
-- Dragon_Fire
-- Dragon_Frost
-- Dragon_Void
-- Duck
-- Eel_Moray
-- Egg
-- Emberwulf
-- Eye_Void
-- Eye_Void_Blast
-- Fen_Stalker
-- Feran
-- Feran_Burrower
-- Feran_Civilian
-- Feran_Cub
-- Feran_Longtooth
-- Feran_Sharptooth
-- Feran_Windwalker
-- Feran_Windwalker_Wind_Burst
-- Feran_Windwalker_Wind_Vortex
-- Finch_Green
-- Fireball
-- Flamingo
-- Fox
-- Frog_Blue
-- Frog_Green
-- Frog_Orange
-- Frostgill
-- Gecko
-- Ghoul
-- Goat
-- Goat_Kid
-- Goblin
-- Goblin_Boss
-- Goblin_Duke
-- Goblin_Duke_Large
-- Goblin_Hermit
-- Goblin_Lobber
-- Goblin_Miner
-- Goblin_Ogre
-- Goblin_Scrapper
-- Goblin_Thief
-- Golem_Crystal_Earth
-- Golem_Crystal_Flame
-- Golem_Crystal_Frost
-- Golem_Crystal_Sand
-- Golem_Crystal_Thunder
-- Golem_Firesteel
-- Golem_Guardian_Void
-- Grooble
-- Hatworm
-- Hawk
-- Healing_Totem
-- Healing_Totem_Projectile
-- Hedera
-- Horse
-- Horse_Foal
-- Horse_Skeleton
-- Horse_Skeleton_Armored
-- Hound_Bleached
-- Hyena
-- Ice_Ball
-- Ice_Bolt
-- Ingredient_Poop
-- Jellyfish_Blue
-- Jellyfish_Cyan
-- Jellyfish_Green
-- Jellyfish_Man_Of_War
-- Jellyfish_Red
-- Jellyfish_Yellow
-- Klops
-- Klops_Gentleman
-- Klops_Merchant
-- Klops_Miner
-- Kunai
-- Kweebec_Rootling
-- Kweebec_Sapling
-- Kweebec_Sapling_Brown
-- Kweebec_Sapling_Christmas_Blue
-- Kweebec_Sapling_Christmas_Green
-- Kweebec_Sapling_Christmas_Pink
-- Kweebec_Sapling_Green
-- Kweebec_Sapling_HardHat
-- Kweebec_Sapling_Orange
-- Kweebec_Sapling_Pink
-- Kweebec_Sapling_Razorleaf
-- Kweebec_Sapling_Red
-- Kweebec_Sapling_Treesinger
-- Kweebec_Sapling_Yellow
-- Kweebec_Seedling
-- Kweebec_Sproutling
-- Kweebec_Sproutling_Blue
-- Kweebec_Sproutling_Lime
-- Lamb
-- Larva_Silk
-- Larva_Void
-- Leopard_Snow
-- Lizard_Sand
-- Lobster
-- Mannequin
-- Meerkat
-- Minecart
-- Minnow
-- Model_Bee_Swarm
-- Model_Deer_Stag
-- Molerat
-- Moose_Bull
-- Moose_Cow
-- Mosshorn
-- Mosshorn_Plain
-- Mouflon
-- Mouflon_Lamb
-- Mouse
-- Mushee
-- NPC_Elf
-- NPC_Path_Marker
-- NPC_Santa
-- NPC_Sound_Shoe
-- NPC_Spawn_Marker
-- Necromancer_Void
-- Objective_Location_Marker
-- Outlander
-- Outlander_Berserker
-- Outlander_Brute
-- Outlander_Cultist
-- Outlander_Hunter
-- Outlander_Marauder
-- Outlander_Peon
-- Outlander_Priest
-- Outlander_Sorcerer
-- Outlander_Stalker
-- Owl_Brown
-- Owl_Snow
-- Parrot
-- Penguin
-- Pig
-- Pig_Undead
-- Pig_Wild
-- Pigeon
-- Piglet
-- Piglet_Wild
-- Pike
-- Piranha
-- Piranha_Black
-- Player
-- PlayerTestModel_G
-- PlayerTestModel_V
-- Projectile
-- Pterodactyl
-- Pufferfish
-- Rabbit
-- Ram
-- Ram_Lamb
-- Raptor_Cave
-- Rat
-- Raven
-- Reindeer_Christmas
-- Rex_Cave
-- Rubble_Aqua
-- Rubble_Basalt
-- Rubble_Calcite
-- Rubble_Default
-- Rubble_Ice
-- Rubble_Marble
-- Rubble_Quartzite
-- Rubble_Sandstone
-- Rubble_Sandstone_Red
-- Rubble_Sandstone_White
-- Rubble_Shale
-- Rubble_Slate
-- Rubble_Stone
-- Rubble_Stone_Mossy
-- Rubble_Volcanic
-- Salmon
-- Saurian
-- Saurian_Hunter
-- Saurian_Rogue
-- Saurian_Warrior
-- Scarak_Broodmother
-- Scarak_Broodmother_Young
-- Scarak_Defender
-- Scarak_Fighter
-- Scarak_Fighter_Royal_Guard
-- Scarak_Louse
-- Scarak_Seeker
-- Scarak_Seeker_Spitball
-- Scorpion
-- Shadow_Knight
-- Shark_Hammerhead
-- Sheep
-- Shellfish_Lava
-- Showcase_Cobalt_Gear
-- Showcase_Copper_Gear
-- Showcase_Iron_Gear
-- Showcase_Iron_TargetDummy_1
-- Showcase_Mannequin_Heal
-- Showcase_Mannequin_Inv_Portal
-- Showcase_Mannequin_Inv_Sphere
-- Showcase_Mannequin_Lightning
-- Showcase_Mannequin_Sitting
-- Showcase_Onyxium_Gear
-- Showcase_Prisma_Gear
-- Showcase_Skeleton_Assasin
-- Showcase_Skeleton_Dead
-- Showcase_Skeleton_Guard
-- Showcase_Skeleton_Tank
-- Showcase_Wooden_Gear
-- Skeleton
-- Skeleton_Archer
-- Skeleton_Archmage
-- Skeleton_Burnt_Alchemist
-- Skeleton_Burnt_Archer
-- Skeleton_Burnt_Gunner
-- Skeleton_Burnt_Knight
-- Skeleton_Burnt_Lancer
-- Skeleton_Burnt_Praetorian
-- Skeleton_Burnt_Soldier
-- Skeleton_Burnt_Wizard
-- Skeleton_Fighter
-- Skeleton_Frost_Archer
-- Skeleton_Frost_Archmage
-- Skeleton_Frost_Fighter
-- Skeleton_Frost_Knight
-- Skeleton_Frost_Mage
-- Skeleton_Frost_Ranger
-- Skeleton_Frost_Scout
-- Skeleton_Frost_Soldier
-- Skeleton_Incandescent_Fighter
-- Skeleton_Incandescent_Footman
-- Skeleton_Incandescent_Head
-- Skeleton_Incandescent_Mage
-- Skeleton_Knight
-- Skeleton_Mage
-- Skeleton_Mage_Corruption_Orb
-- Skeleton_Pirate_Captain
-- Skeleton_Pirate_Gunner
-- Skeleton_Pirate_Striker
-- Skeleton_Ranger
-- Skeleton_Sand_Archer
-- Skeleton_Sand_Archmage
-- Skeleton_Sand_Assassin
-- Skeleton_Sand_Guard
-- Skeleton_Sand_Mage
-- Skeleton_Sand_Ranger
-- Skeleton_Sand_Scout
-- Skeleton_Sand_Soldier
-- Skeleton_Scout
-- Skeleton_Soldier
-- Skrill
-- Skrill_Chick
-- Slothian
-- Slothian_Elder
-- Slothian_Kid
-- Slothian_Monk
-- Slothian_Scout
-- Slothian_Villager
-- Slothian_Warrior
-- Slowness_Totem
-- Slowness_Totem_Projectile
-- Slug_Magma
-- Snail_Frost
-- Snail_Magma
-- Snake_Cobra
-- Snake_Marsh
-- Snake_Rattle
-- Snapdragon
-- Snapjaw
-- Spark_Living
-- Sparrow
-- Spawn_Void
-- Spear_Adamantite
-- Spear_Adamantite_Saurian
-- Spear_Bone
-- Spear_Bronze
-- Spear_Cobalt
-- Spear_Copper
-- Spear_Crude
-- Spear_Double_Incandescent
-- Spear_Iron
-- Spear_Leaf
-- Spear_Mithril
-- Spear_Onyxium
-- Spear_Scrap
-- Spear_Stone_Trork
-- Spear_Thorium
-- Spear_Tribal
-- Spectre_Void
-- Spider
-- Spider_Cave
-- Spirit_Ember
-- Spirit_Frost
-- Spirit_Root
-- Spirit_Thunder
-- Squirrel
-- Swarm_Bees
-- Sword_Charged_Test
-- Tang_Blue
-- Tang_Chevron
-- Tang_Lemon_Peel
-- Tang_Sailfin
-- Tank
-- Temple_Mithril_Guard
-- Test_Platform
-- Tetrabird
-- Tiger_Sabertooth
-- Toad_Rhino
-- Toad_Rhino_Magma
-- Tornado
-- Tortoise
-- Trash
-- Trillodon
-- Trilobite
-- Trilobite_Black
-- Trork
-- Trork_Brawler
-- Trork_Chieftain
-- Trork_Christmas
-- Trork_Doctor_Witch
-- Trork_Guard
-- Trork_Hunter
-- Trork_Mauler
-- Trork_Sentry
-- Trork_Shaman
-- Trork_Warrior
-- Trout_Rainbow
-- Tuluk
-- Tuluk_Fisherman
-- Turkey
-- Turkey_Chick
-- Vulture
-- Warp
-- Warrior_Quest
-- Warthog
-- Warthog_Piglet
-- Werewolf
-- Whale_Humpback
-- Wolf_Black
-- Wolf_Outlander_Priest
-- Wolf_Outlander_Sorcerer
-- Wolf_Trork_Hunter
-- Wolf_Trork_Shaman
-- Wolf_White
-- Woodpecker
-- Wraith
-- Wraith_Lantern
-- Wurmling_Frost
-- Yeti
-- Zombie
-- Zombie_Aberrant
-- Zombie_Aberrant_Big
-- Zombie_Aberrant_Small
-- Zombie_Burnt
-- Zombie_Frost
-- Zombie_Sand
-- Zombie_Werewolf
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
diff --git a/content/docs/ja-JP/server/events.mdx b/content/docs/ja-JP/server/events.mdx
index ca7ed28f..4ba66880 100644
--- a/content/docs/ja-JP/server/events.mdx
+++ b/content/docs/ja-JP/server/events.mdx
@@ -1,104 +1,104 @@
 ---
-title: Events
-description: List of all events in Hytale
-icon: List
+title: イベント
+description: Hytale 内の全てのイベントの一覧
+icon: ""
 full: true
 ---
 
-## IEvent
+##
 
-- AddPlayerToWorldEvent
-- AllNPCsLoadedEvent
-- AllWorldsLoadedEvent
-- AssetMonitorEvent
-  - AssetStoreMonitorEvent
-  - CommonAssetMonitorEvent
-- AssetPackRegisterEvent
-- AssetPackUnregisterEvent
-- AssetStoreEvent
-  - RegisterAssetStoreEvent
-  - RemoveAssetStoreEvent
-- AssetsEvent
-  - GenerateAssetsEvent
-  - LoadedAssetsEvent
-  - RemovedAssetsEvent
-- BootEvent
-- ChunkEvent
-  - ChunkPreLoadProcessEvent
-- DrainPlayerFromWorldEvent
-- EditorClientEvent
-  - AssetEditorActivateButtonEvent
-  - AssetEditorAssetCreatedEvent
-  - AssetEditorClientDisconnectEvent
-  - AssetEditorSelectAssetEvent
-  - AssetEditorUpdateWeatherPreviewLockEvent
-- EntityEvent
-  - EntityRemoveEvent
-  - LivingEntityInventoryChangeEvent
-- GenerateDefaultLanguageEvent
-- GenerateSchemaEvent
-- GenerateServerStateEvent
-- ItemContainerChangeEvent
-- ~~LivingEntityUseBlockEvent~~ DEPRECATED
-- LoadAssetEvent
-- LoadedNPCEvent
-- MessagesUpdated
-- PlayerConnectEvent
-- PlayerEvent
-  - ~~PlayerCraftEvent~~ DEPRECATED
-  - ~~PlayerInteractEvent~~ DEPRECATED
-  - PlayerMouseButtonEvent
-  - PlayerMouseMotionEvent
-  - PlayerReadyEvent
-  - RemovePlayerFromWorldEvent
-- PlayerRefEvent
-  - PlayerDisconnectEvent
-- PlayerSetupConnectEvent
-- PlayerSetupDisconnectEvent
-- PluginEvent
-  - PluginSetupEvent
-- ~~PrepareUniverseEvent~~ DEPRECATED
-- ShutdownEvent
-- SingleplayerRequestAccessEvent
-- TreasureChestOpeningEvent
-- WindowCloseEvent
-- WorldEvent
-  - AddWorldEvent
-  - RemoveWorldEvent
-  - StartWorldEvent
-- WorldPathChangedEvent
+-
+-
+-
+-
+  -
+  -
+-
+-
+-
+  -
+  -
+-
+  -
+  -
+  -
+-
+-
+  -
+-
+-
+  -
+  -
+  -
+  -
+  -
+-
+  -
+  -
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+  -
+  -
+  -
+  -
+  -
+  -
+-
+  -
+-
+-
+-
+  -
+-
+-
+-
+-
+-
+-
+  -
+  -
+  -
+-
 
-## IAsyncEvent
+##
 
-- AssetEditorFetchAutoCompleteDataEvent
-- AssetEditorRequestDataSetEvent
-- PlayerChatEvent
-- SendCommonAssetsEvent
+-
+-
+-
+-
 
-## EcsEvent
+##
 
-- CancellableEcsEvent
-  - BreakBlockEvent
-  - ChangeGameModeEvent
-  - ChunkSaveEvent
-  - ChunkUnloadEvent
-  - CraftRecipeEvent
-    - Post
-    - Pre
-  - Damage
-  - DamageBlockEvent
-  - DropItemEvent
-    - Drop
-    - PlayerRequest
-  - InteractivelyPickupItemEvent
-  - PlaceBlockEvent
-  - PrefabPasteEvent
-  - SwitchActiveSlotEvent
-- DiscoverInstanceEvent
-  - Display
-- DiscoverZoneEvent
-  - Display
-- MoonPhaseChangeEvent
-- UseBlockEvent
-  - Post
-  - Pre
+-
+  -
+  -
+  -
+  -
+  -
+    -
+    -
+  -
+  -
+  -
+    -
+    -
+  -
+  -
+  -
+  -
+-
+  -
+-
+  -
+-
+-
+  -
+  -
diff --git a/content/docs/ja-JP/server/sounds.mdx b/content/docs/ja-JP/server/sounds.mdx
index 5b54a035..3dce5ca3 100644
--- a/content/docs/ja-JP/server/sounds.mdx
+++ b/content/docs/ja-JP/server/sounds.mdx
@@ -1,1162 +1,1162 @@
 ---
-title: Sounds
-description: List of all Sounds in Hytale
-icon: List
+title: サウンド
+description: Hytale 内の全てのサウンドの一覧
+icon: ""
 full: true
 ---
 
-This page contains a list of all Sounds available to be used as a key in the AssetMap.
+このページには、AssetMap 内のキーとして使用できるすべてのサウンドのリストが含まれています。
 
-- SFX_Alchemy_Bench_Close
-- SFX_Alchemy_Bench_Craft
-- SFX_Alchemy_Bench_Open
-- SFX_Antelope_Alerted
-- SFX_Antelope_Death
-- SFX_Antelope_Hurt
-- SFX_Antelope_Run
-- SFX_Antelope_Walk
-- SFX_Arcane_Workbench_Close_Local
-- SFX_Arcane_Workbench_Craft
-- SFX_Arcane_Workbench_Open_Local
-- SFX_Armour_Bench_Close
-- SFX_Armour_Bench_Craft
-- SFX_Armour_Bench_Open
-- SFX_Arrow_Fire_Hit
-- SFX_Arrow_Fire_Miss
-- SFX_Arrow_Frost_Hit
-- SFX_Arrow_Frost_Miss
-- SFX_Arrow_FullCharge_Hit
-- SFX_Arrow_FullCharge_Miss
-- SFX_Arrow_HalfCharge_Hit
-- SFX_Arrow_HalfCharge_Miss
-- SFX_Arrow_NoCharge_Hit
-- SFX_Arrow_NoCharge_Miss
-- SFX_Arrow_Whistle
-- SFX_Attn_Loud
-- SFX_Attn_Moderate
-- SFX_Attn_Quiet
-- SFX_Attn_VeryLoud
-- SFX_Attn_VeryQuiet
-- SFX_Avatar_Powers_Disable
-- SFX_Avatar_Powers_Disable_Local
-- SFX_Avatar_Powers_Enable
-- SFX_Avatar_Powers_Enable_Local
-- SFX_Axe_Crude_Impact
-- SFX_Axe_Crude_Swing
-- SFX_Axe_Iron_Impact
-- SFX_Axe_Iron_Swing
-- SFX_Axe_Special_Impact
-- SFX_Axe_Special_Swing
-- SFX_Axe_Stone_Trork_Hit
-- SFX_Axe_Stone_Trork_Miss
-- SFX_Bat_Alerted
-- SFX_Bat_Death
-- SFX_Bat_Hurt
-- SFX_Battleaxe_T1_Block_Impact
-- SFX_Battleaxe_T1_Impact
-- SFX_Battleaxe_T1_Launch
-- SFX_Battleaxe_T1_Launch_Local
-- SFX_Battleaxe_T1_Raise
-- SFX_Battleaxe_T1_Raise_Local
-- SFX_Battleaxe_T1_Shove
-- SFX_Battleaxe_T1_Shove_Local
-- SFX_Battleaxe_T1_Swing
-- SFX_Battleaxe_T1_Swing_Charged
-- SFX_Battleaxe_T1_Swing_Charged_Local
-- SFX_Battleaxe_T1_Swing_Down_Local
-- SFX_Battleaxe_T1_Swing_LR_Local
-- SFX_Battleaxe_T1_Swing_RL_Local
-- SFX_Battleaxe_T2_Impact
-- SFX_Battleaxe_T2_Raise
-- SFX_Battleaxe_T2_Raise_Local
-- SFX_Battleaxe_T2_Signature_End
-- SFX_Battleaxe_T2_Signature_End_Local
-- SFX_Battleaxe_T2_Signature_Swing
-- SFX_Battleaxe_T2_Signature_Swing_Local
-- SFX_Battleaxe_T2_Swing
-- SFX_Battleaxe_T2_Swing_Charged
-- SFX_Battleaxe_T2_Swing_Charged_Local
-- SFX_Battleaxe_T2_Swing_Down_Local
-- SFX_Battleaxe_T2_Swing_LR_Local
-- SFX_Battleaxe_T2_Swing_RL_Local
-- SFX_Bear_Grizzly_Alerted
-- SFX_Bear_Grizzly_Attack
-- SFX_Bear_Grizzly_Death
-- SFX_Bear_Grizzly_Hurt
-- SFX_Bear_Grizzly_Run
-- SFX_Bear_Grizzly_Sleep
-- SFX_Bear_Walk
-- SFX_Bench_Placeholder
-- SFX_Bison_Alerted
-- SFX_Bison_Death
-- SFX_Bison_Hurt
-- SFX_Bison_Idle
-- SFX_Bison_Run
-- SFX_Bison_Walk
-- SFX_Blunderbuss_Bullet_WhizBy
-- SFX_Blunderbuss_Fire
-- SFX_Blunderbuss_Fire_Local
-- SFX_Blunderbuss_Hit
-- SFX_Blunderbuss_Load
-- SFX_Blunderbuss_Load_Local
-- SFX_Blunderbuss_Miss
-- SFX_Blunderbuss_No_Ammo
-- SFX_Boar_Alerted
-- SFX_Boar_Death
-- SFX_Boar_Hurt
-- SFX_Boar_Run
-- SFX_Boar_Sleep
-- SFX_Boar_Walk
-- SFX_Bomb_Fire_Goblin_Bounce
-- SFX_Bomb_Fire_Goblin_Death
-- SFX_Bomb_Fire_Goblin_Hit
-- SFX_Bomb_Fire_Goblin_Miss
-- SFX_Bomb_Fuse
-- SFX_Bone_Break
-- SFX_Bone_Build
-- SFX_Bone_Hit
-- SFX_Bone_Land
-- SFX_Bone_Walk
-- SFX_Bow_No_Ammo
-- SFX_Bow_T1_Block_Impact
-- SFX_Bow_T1_Draw
-- SFX_Bow_T1_Draw_Local
-- SFX_Bow_T1_Raise
-- SFX_Bow_T1_Raise_Local
-- SFX_Bow_T1_Shoot
-- SFX_Bow_T1_Shoot_Local
-- SFX_Bow_T1_Swing
-- SFX_Bow_T1_Swing_Local
-- SFX_Bow_T2_Draw
-- SFX_Bow_T2_Draw_Local
-- SFX_Bow_T2_Shoot
-- SFX_Bow_T2_Shoot_Local
-- SFX_Bow_T2_Signature_Loop
-- SFX_Bow_T2_Signature_Loop_Local
-- SFX_Bow_T2_Signature_Nock
-- SFX_Bow_T2_Signature_Nock_Local
-- SFX_Bow_T2_Signature_Shoot
-- SFX_Bow_T2_Signature_Shoot_Local
-- SFX_Bramble_MoveIn
-- SFX_Branch_Break
-- SFX_Branch_Build
-- SFX_Branch_Hit
-- SFX_Branch_Land
-- SFX_Branch_Walk
-- SFX_Brazier_Break
-- SFX_Brazier_Build
-- SFX_Bunny_Alerted
-- SFX_Bunny_Death
-- SFX_Bunny_Hurt
-- SFX_Bush_Break
-- SFX_Bush_Hit
-- SFX_Bush_MoveIn
-- SFX_Cactus_Break
-- SFX_Cactus_Hit
-- SFX_Cactus_Large_Hit
-- SFX_Cactus_Small_Break
-- SFX_Cactus_Small_Hit
-- SFX_Calf_Hurt
-- SFX_Calf_Run
-- SFX_Calf_Walk
-- SFX_Camel_Alerted
-- SFX_Camel_Death
-- SFX_Camel_Hurt
-- SFX_Camel_Laydown
-- SFX_Camel_Run
-- SFX_Camel_Sleep
-- SFX_Camel_Wake
-- SFX_Camel_Walk
-- SFX_Campfire_Break
-- SFX_Campfire_Build
-- SFX_Campfire_Close_Local
-- SFX_Campfire_Default_Loop
-- SFX_Campfire_Open_Local
-- SFX_Campfire_Processing
-- SFX_Campfire_Processing_End
-- SFX_Campfire_Processing_Failed
-- SFX_Candle_Default_Loop
-- SFX_Candle_Off
-- SFX_Capture_Crate_Capture_Fail_Local
-- SFX_Capture_Crate_Capture_Succeed
-- SFX_Capture_Crate_Capture_Succeed_Local
-- SFX_Capture_Crate_Spawn_Fail_Local
-- SFX_Capture_Crate_Spawn_Succeed
-- SFX_Cauldron_Bubbling
-- SFX_Cauldron_Bubbling_Small
-- SFX_Chest_Legendary_Close_Player
-- SFX_Chest_Legendary_FirstOpen_Player
-- SFX_Chest_Legendary_Loop
-- SFX_Chest_Legendary_Open
-- SFX_Chest_Wooden_Close
-- SFX_Chest_Wooden_Open
-- SFX_Chest_Wooden_Open_Player
-- SFX_Chick_Alerted
-- SFX_Chick_Death
-- SFX_Chick_Hurt
-- SFX_Chicken_Alerted
-- SFX_Chicken_Death
-- SFX_Chicken_Flee
-- SFX_Chicken_Hurt
-- SFX_Chicken_Run
-- SFX_Chicken_Walk
-- SFX_Clay_Pot_Large_Break
-- SFX_Clay_Pot_Large_Build
-- SFX_Clay_Pot_Large_Hit
-- SFX_Clay_Pot_Large_Walk
-- SFX_Clay_Pot_Small_Break
-- SFX_Clay_Pot_Small_Build
-- SFX_Clay_Pot_Small_Hit
-- SFX_Clay_Pot_Small_Walk
-- SFX_Cloth_Break
-- SFX_Cloth_Build
-- SFX_Cloth_Hit
-- SFX_Cloth_Land
-- SFX_Cloth_Walk
-- SFX_Club_Meat_Impact
-- SFX_Club_Meat_Swing
-- SFX_Club_Special_Impact
-- SFX_Club_Special_Swing
-- SFX_Club_Steel_Impact
-- SFX_Club_Steel_Swing
-- SFX_Club_Wood_Impact
-- SFX_Club_Wood_Swing
-- SFX_Cocoon_Active
-- SFX_Cocoon_Break
-- SFX_Cocoon_Build
-- SFX_Cocoon_Hit
-- SFX_Cocoon_Walk
-- SFX_Coins_Land
-- SFX_Coins_Walk
-- SFX_Consume_Bread
-- SFX_Consume_Bread_Local
-- SFX_Cow_Alerted
-- SFX_Cow_Death
-- SFX_Cow_Hurt
-- SFX_Cow_Idle
-- SFX_Cow_Run
-- SFX_Cow_Sleep
-- SFX_Cow_Walk
-- SFX_Crawler_Void_Alerted
-- SFX_Crawler_Void_Alerted_02
-- SFX_Crawler_Void_Death
-- SFX_Crawler_Void_Despawn
-- SFX_Crawler_Void_Hurt
-- SFX_Crawler_Void_Run
-- SFX_Crawler_Void_Sleep
-- SFX_Crawler_Void_Spawn
-- SFX_Crawler_Void_Spawn_02
-- SFX_Crawler_Void_Walk
-- SFX_Creative_Play_Add_Mask
-- SFX_Creative_Play_Brush_Erase
-- SFX_Creative_Play_Brush_Mode
-- SFX_Creative_Play_Brush_Paint_Base
-- SFX_Creative_Play_Brush_Paint_Idle_Layer
-- SFX_Creative_Play_Brush_Paint_Move_Layer
-- SFX_Creative_Play_Brush_Shape
-- SFX_Creative_Play_Brush_Stamp
-- SFX_Creative_Play_Error
-- SFX_Creative_Play_Eyedropper_Select
-- SFX_Creative_Play_Paste
-- SFX_Creative_Play_Selection_Drag
-- SFX_Creative_Play_Selection_Place
-- SFX_Creative_Play_Selection_Scale
-- SFX_Creative_Play_Selection_Widget
-- SFX_Creative_Play_Set_Mask
-- SFX_Crocodile_Alerted
-- SFX_Crocodile_Death
-- SFX_Crocodile_Hurt
-- SFX_Crops_Grow
-- SFX_Crops_Grow_Stage_Complete
-- SFX_Crow_Death
-- SFX_Crow_Hurt
-- SFX_Crystal_Break
-- SFX_Crystal_Build
-- SFX_Crystal_Hit
-- SFX_Crystal_Walk
-- SFX_Daggers_T1_Guard
-- SFX_Daggers_T1_Guard_Local
-- SFX_Daggers_T1_Pounce
-- SFX_Daggers_T1_Pounce_Local
-- SFX_Daggers_T1_Slash_Impact
-- SFX_Daggers_T1_Stab_Double_Impact
-- SFX_Daggers_T1_Stab_Impact
-- SFX_Daggers_T1_Stab_Left_Local
-- SFX_Daggers_T1_Stab_Retreat
-- SFX_Daggers_T1_Stab_Retreat_Local
-- SFX_Daggers_T1_Stab_Right_Local
-- SFX_Daggers_T1_Swing
-- SFX_Daggers_T1_Swing_Double
-- SFX_Daggers_T1_Swing_Double_Local
-- SFX_Daggers_T1_Swing_LR_Local
-- SFX_Daggers_T1_Swing_RL_Local
-- SFX_Daggers_T2_Guard
-- SFX_Daggers_T2_Guard_Local
-- SFX_Daggers_T2_Signature_P1
-- SFX_Daggers_T2_Signature_P1_Local
-- SFX_Daggers_T2_Signature_P2
-- SFX_Daggers_T2_Signature_P2_Local
-- SFX_Daggers_T2_Signature_P3
-- SFX_Daggers_T2_Signature_P3_Local
-- SFX_Daggers_T2_Slash_Impact
-- SFX_Daggers_T2_Stab_Double_Impact
-- SFX_Daggers_T2_Stab_Impact
-- SFX_Daggers_T2_Stab_Left_Local
-- SFX_Daggers_T2_Stab_Retreat
-- SFX_Daggers_T2_Stab_Retreat_Local
-- SFX_Daggers_T2_Stab_Right_Local
-- SFX_Daggers_T2_Swing
-- SFX_Daggers_T2_Swing_Double
-- SFX_Daggers_T2_Swing_Double_Local
-- SFX_Daggers_T2_Swing_LR_Local
-- SFX_Daggers_T2_Swing_RL_Local
-- SFX_Deer_Doe_Alerted
-- SFX_Deer_Doe_Death
-- SFX_Deer_Doe_Hurt
-- SFX_Deer_Doe_Run
-- SFX_Deer_Doe_Sleep
-- SFX_Deer_Stag_Alerted
-- SFX_Deer_Stag_Death
-- SFX_Deer_Stag_Hurt
-- SFX_Deer_Stag_Roar
-- SFX_Deer_Stag_Run
-- SFX_Deer_Stag_Sleep
-- SFX_Deer_Walk
-- SFX_Default_Break
-- SFX_Default_Build
-- SFX_Default_Clone
-- SFX_Default_Harvest
-- SFX_Default_Walk
-- SFX_Deployable_Totem_Heal_Despawn
-- SFX_Deployable_Totem_Heal_Effect_Local
-- SFX_Deployable_Totem_Heal_Spawn
-- SFX_Deployable_Totem_Slowing_Despawn
-- SFX_Deployable_Totem_Slowing_Effect_Local
-- SFX_Deployable_Totem_Slowing_Spawn
-- SFX_Dirt_Break
-- SFX_Dirt_Build
-- SFX_Dirt_Clone
-- SFX_Dirt_Hit
-- SFX_Dirt_Land
-- SFX_Dirt_Walk
-- SFX_Discovery_Z1_Medium
-- SFX_Discovery_Z1_Short
-- SFX_Discovery_Z2_Medium
-- SFX_Discovery_Z2_Short
-- SFX_Discovery_Z3_Medium
-- SFX_Discovery_Z3_Short
-- SFX_Discovery_Z4_Medium
-- SFX_Discovery_Z4_Short
-- SFX_Divine_Respawn
-- SFX_Door_Ancient_Close
-- SFX_Door_Ancient_Open
-- SFX_Door_Crude_Close
-- SFX_Door_Crude_Open
-- SFX_Door_Desert_Close
-- SFX_Door_Desert_Open
-- SFX_Door_Jungle_Close
-- SFX_Door_Jungle_Open
-- SFX_Door_Lumberjack_Close
-- SFX_Door_Lumberjack_Open
-- SFX_Door_Temple_Dark_Close
-- SFX_Door_Temple_Dark_Open
-- SFX_Door_Temple_Light_Close
-- SFX_Door_Temple_Light_Open
-- SFX_Door_Wooden_Close
-- SFX_Door_Wooden_Open
-- SFX_Drag_Armor_Cloth
-- SFX_Drag_Armor_Heavy
-- SFX_Drag_Armor_Leather
-- SFX_Drag_Blocks_Gravel
-- SFX_Drag_Blocks_Soft
-- SFX_Drag_Blocks_Splatty
-- SFX_Drag_Blocks_Stone
-- SFX_Drag_Blocks_Wood
-- SFX_Drag_Item_Default
-- SFX_Drag_Items_Bones
-- SFX_Drag_Items_Chest
-- SFX_Drag_Items_Clay
-- SFX_Drag_Items_Cloth
-- SFX_Drag_Items_Foliage
-- SFX_Drag_Items_Gadget
-- SFX_Drag_Items_Gems
-- SFX_Drag_Items_Ingots
-- SFX_Drag_Items_Leather
-- SFX_Drag_Items_Metal
-- SFX_Drag_Items_Paper
-- SFX_Drag_Items_Potion
-- SFX_Drag_Items_Seeds
-- SFX_Drag_Items_Shells
-- SFX_Drag_Items_Splatty
-- SFX_Drag_Weapon_Blade_Small
-- SFX_Drag_Weapon_Blunt_Large
-- SFX_Drag_Weapons_Arrows
-- SFX_Drag_Weapons_Blade_Large
-- SFX_Drag_Weapons_Blunt_Small
-- SFX_Drag_Weapons_Books
-- SFX_Drag_Weapons_Shield_Metal
-- SFX_Drag_Weapons_Shield_Wood
-- SFX_Drag_Weapons_Stone_Large
-- SFX_Drag_Weapons_Stone_Small
-- SFX_Drag_Weapons_Wand
-- SFX_Drag_Weapons_Wood
-- SFX_Dragon_Sleep
-- SFX_Drop_Armor_Cloth
-- SFX_Drop_Armor_Heavy
-- SFX_Drop_Armor_Leather
-- SFX_Drop_Blocks_Gravel
-- SFX_Drop_Blocks_Soft
-- SFX_Drop_Blocks_Splatty
-- SFX_Drop_Blocks_Stone
-- SFX_Drop_Blocks_Wood
-- SFX_Drop_Item_Default
-- SFX_Drop_Items_Bones
-- SFX_Drop_Items_Chest
-- SFX_Drop_Items_Clay
-- SFX_Drop_Items_Cloth
-- SFX_Drop_Items_Foliage
-- SFX_Drop_Items_Gadget
-- SFX_Drop_Items_Gems
-- SFX_Drop_Items_Ingots
-- SFX_Drop_Items_Leather
-- SFX_Drop_Items_Metal
-- SFX_Drop_Items_Paper
-- SFX_Drop_Items_Potion
-- SFX_Drop_Items_Seeds
-- SFX_Drop_Items_Shells
-- SFX_Drop_Items_Splatty
-- SFX_Drop_Weapon_Blade_Small
-- SFX_Drop_Weapon_Blunt_Large
-- SFX_Drop_Weapons_Arrows
-- SFX_Drop_Weapons_Blade_Large
-- SFX_Drop_Weapons_Blunt_Small
-- SFX_Drop_Weapons_Books
-- SFX_Drop_Weapons_Shield_Metal
-- SFX_Drop_Weapons_Shield_Wood
-- SFX_Drop_Weapons_Stone_Large
-- SFX_Drop_Weapons_Stone_Small
-- SFX_Drop_Weapons_Wand
-- SFX_Drop_Weapons_Wood
-- SFX_Duck_Alerted
-- SFX_Duck_Death
-- SFX_Duck_Hurt
-- SFX_Duck_Run
-- SFX_Effect_Burn_Local
-- SFX_Effect_Burn_World
-- SFX_Effect_Poison_Local
-- SFX_Effect_Poison_World
-- SFX_Egg_Hit
-- SFX_Egg_Miss
-- SFX_Eggsac_Active
-- SFX_Emberwulf_Alerted
-- SFX_Emberwulf_Attack_Bite
-- SFX_Emberwulf_Death
-- SFX_Emberwulf_Hurt
-- SFX_Emberwulf_Run
-- SFX_Emberwulf_Sleep
-- SFX_Emberwulf_Walk
-- SFX_Emit_Forgotten_Whispers
-- SFX_Emit_Lake_Water
-- SFX_Emit_Temple_Wisps
-- SFX_Emit_Tree_Creak
-- SFX_Emit_Wind_Grass
-- SFX_Emit_Wind_Gusts
-- SFX_Env_Emit_Fluid_Lava
-- SFX_Env_Emit_Fluid_Water
-- SFX_Env_Emit_Fluid_Water_Far
-- SFX_Env_Emit_Geyzer
-- SFX_Eye_Void_Alerted
-- SFX_Eye_Void_Attack_Blast
-- SFX_Eye_Void_Attack_Summon
-- SFX_Eye_Void_Death
-- SFX_Eye_Void_Fly_Movement
-- SFX_Eye_Void_Hurt
-- SFX_Eye_Void_Idle
-- SFX_Fen_Stalker_Alerted
-- SFX_Fen_Stalker_Attack_Swing
-- SFX_Fen_Stalker_Attack_Swipe
-- SFX_Fen_Stalker_Death
-- SFX_Fen_Stalker_Eat
-- SFX_Fen_Stalker_Eat_Finish
-- SFX_Fen_Stalker_Greet
-- SFX_Fen_Stalker_Hurt
-- SFX_Fen_Stalker_Run
-- SFX_Fen_Stalker_Scared
-- SFX_Fen_Stalker_Seek
-- SFX_Fen_Stalker_Sniff
-- SFX_Feran_Death
-- SFX_Fern_Break
-- SFX_Fern_MoveIn
-- SFX_Fireball_Bounce
-- SFX_Fireball_Death
-- SFX_Fireball_Miss
-- SFX_Fish_Death
-- SFX_Fish_Flee
-- SFX_Fish_Hurt
-- SFX_Flail_Charge
-- SFX_Flail_Charge_Local
-- SFX_Flail_Swing
-- SFX_Flail_Swing_Left_Local
-- SFX_Flail_Swing_Right_Local
-- SFX_Flame_Break
-- SFX_Flame_Build
-- SFX_Flame_Default_Loop
-- SFX_Flamingo_Alerted
-- SFX_Flamingo_Death
-- SFX_Flamingo_Fly
-- SFX_Flamingo_Hurt
-- SFX_Forgotten_Temple_Emit_Birds
-- SFX_Forgotten_Temple_Emit_Birds_Interior
-- SFX_Fox_Alerted
-- SFX_Fox_Death
-- SFX_Fox_Hurt
-- SFX_Fox_Run
-- SFX_Fox_Sleep
-- SFX_Frog_Alerted
-- SFX_Frog_Croak
-- SFX_Frog_Death
-- SFX_Frog_Hurt
-- SFX_Frog_Idle
-- SFX_Frog_Run
-- SFX_Furnace_Bench_Close
-- SFX_Furnace_Bench_Open
-- SFX_Furnace_Bench_Processing
-- SFX_Furnace_Bench_Processing_Complete
-- SFX_Furnace_Bench_Processing_End
-- SFX_Furnace_Bench_Processing_Failed
-- SFX_Gecko_Alerted
-- SFX_Gecko_Death
-- SFX_Gecko_Hurt
-- SFX_Gem_Break
-- SFX_Gem_Emit_Loop
-- SFX_Generic_Crafting_Failed
-- SFX_Glass_Break
-- SFX_Global_Weather_Thunder
-- SFX_Goat_Run
-- SFX_Goat_Walk
-- SFX_Goblin_Alerted
-- SFX_Goblin_Death
-- SFX_Goblin_Hurt
-- SFX_Goblin_Lobber_Bomb_Bounce
-- SFX_Goblin_Lobber_Bomb_Death
-- SFX_Goblin_Lobber_Bomb_Hit
-- SFX_Goblin_Lobber_Bomb_Miss
-- SFX_Goblin_Run
-- SFX_Goblin_Search
-- SFX_Golem_Earth_Alerted
-- SFX_Golem_Earth_Death
-- SFX_Golem_Earth_Hurt
-- SFX_Golem_Earth_Laydown
-- SFX_Golem_Earth_Slam
-- SFX_Golem_Earth_Slam_Impact
-- SFX_Golem_Earth_Spin
-- SFX_Golem_Earth_Stomp
-- SFX_Golem_Earth_Stomp_Impact
-- SFX_Golem_Earth_Swing
-- SFX_Golem_Earth_Swing_Impact
-- SFX_Golem_Earth_Wake
-- SFX_Golem_Firesteel_Alerted_01
-- SFX_Golem_Firesteel_Alerted_02
-- SFX_Golem_Firesteel_Death
-- SFX_Golem_Firesteel_Laydown
-- SFX_Golem_Firesteel_Wake
-- SFX_Golem_Frost_Alerted
-- SFX_Golem_Frost_Death
-- SFX_Golem_Frost_Hurt
-- SFX_Golem_Frost_Laydown
-- SFX_Golem_Frost_Slam
-- SFX_Golem_Frost_Slam_Impact
-- SFX_Golem_Frost_Spin
-- SFX_Golem_Frost_Stomp
-- SFX_Golem_Frost_Swing
-- SFX_Golem_Frost_Swing_Impact
-- SFX_Golem_Frost_Wake
-- SFX_Golem_Sand_Alerted
-- SFX_Golem_Sand_Death
-- SFX_Golem_Sand_Hurt
-- SFX_Golem_Sand_Laydown
-- SFX_Golem_Sand_Slam
-- SFX_Golem_Sand_Slam_Impact
-- SFX_Golem_Sand_Spin
-- SFX_Golem_Sand_Stomp
-- SFX_Golem_Sand_Stomp_Impact
-- SFX_Golem_Sand_Swing
-- SFX_Golem_Sand_Swing_Impact
-- SFX_Golem_Sand_Wake
-- SFX_Grass_Break
-- SFX_Grass_Build
-- SFX_Grass_Hit
-- SFX_Grass_Land
-- SFX_Grass_Walk
-- SFX_Gravel_Break
-- SFX_Gravel_Build
-- SFX_Gravel_Hit
-- SFX_Gravel_Land
-- SFX_Gravel_Walk
-- SFX_GunPvP_Assault_Rifle_Bullet_Death
-- SFX_GunPvP_Grenade_Frag_Bounce
-- SFX_GunPvP_Grenade_Frag_Death
-- SFX_GunPvP_Grenade_Frag_Hit
-- SFX_GunPvP_Grenade_Frag_Miss
-- SFX_GunPvP_Handgun_Bullet_Death
-- SFX_Gun_Fire
-- SFX_Hand_Crossbow_T1_Block_Impact
-- SFX_Hand_Crossbow_T1_Raise
-- SFX_Hand_Crossbow_T1_Raise_Local
-- SFX_Hand_Crossbow_T1_Shove
-- SFX_Hand_Crossbow_T1_Shove_Local
-- SFX_Hand_Crossbow_T2_Load
-- SFX_Hand_Crossbow_T2_Load_Local
-- SFX_Hand_Crossbow_T2_Reload_Start
-- SFX_Hand_Crossbow_T2_Reload_Start_Local
-- SFX_Handgun_Fire
-- SFX_Handgun_Fire_Local
-- SFX_Hatchet_T1_Swing_RL_Local
-- SFX_Hatchet_T2_Impact_Nice
-- SFX_Health_Potion_High_Drink
-- SFX_Health_Potion_High_Drink_Local
-- SFX_Health_Potion_Low_Drink
-- SFX_Health_Potion_Low_Drink_Local
-- SFX_Hedera_Scream
-- SFX_Hoe_T1_Swing_Down_Local
-- SFX_Hoe_T1_Till
-- SFX_Horse_Alerted
-- SFX_Horse_Death
-- SFX_Horse_Hurt
-- SFX_Horse_Idle
-- SFX_Horse_Sleep
-- SFX_Horse_Wake
-- SFX_Hyena_Alerted
-- SFX_Hyena_Death
-- SFX_Hyena_Hurt
-- SFX_Hyena_Idle
-- SFX_Ice_Ball_Death
-- SFX_Ice_Bolt_Death
-- SFX_Ice_Break
-- SFX_Ice_Build
-- SFX_Ice_Hit
-- SFX_Ice_Item_Impact
-- SFX_Ice_Item_Swing
-- SFX_Ice_Land
-- SFX_Ice_Walk
-- SFX_Incorrect_Tool
-- SFX_Item_Break
-- SFX_Item_Repair
-- SFX_Klops_Alerted
-- SFX_Klops_Death
-- SFX_Klops_Hurt
-- SFX_Klops_Idle
-- SFX_Klops_Run
-- SFX_Kweebec_Plushie_Impact
-- SFX_Lamb_Alerted
-- SFX_Lamb_Death
-- SFX_Lamb_Hurt
-- SFX_Larva_Alerted
-- SFX_Larva_Death
-- SFX_Larva_Despawn
-- SFX_Larva_Hurt
-- SFX_Larva_Spawn
-- SFX_LeavesGround_Break
-- SFX_LeavesGround_Hit
-- SFX_LeavesGround_Land
-- SFX_LeavesGround_Walk
-- SFX_Leaves_Break
-- SFX_Leaves_Hit
-- SFX_Leaves_Walk
-- SFX_Leopard_Snow_Alerted
-- SFX_Leopard_Snow_Death
-- SFX_Leopard_Snow_Hurt
-- SFX_Leopard_Snow_Run
-- SFX_Light_Melee_T1_Block
-- SFX_Light_Melee_T1_Guard_Hit
-- SFX_Light_Melee_T1_Impact
-- SFX_Light_Melee_T1_Lunge
-- SFX_Light_Melee_T1_Lunge_Charge
-- SFX_Light_Melee_T1_Shove
-- SFX_Light_Melee_T1_Swing
-- SFX_Light_Melee_T2_Block
-- SFX_Light_Melee_T2_Guard_Break
-- SFX_Light_Melee_T2_Guard_Hit
-- SFX_Light_Melee_T2_Lunge
-- SFX_Light_Melee_T2_Lunge_Charge
-- SFX_Light_Melee_T2_Swing
-- SFX_Longsword_Special_Impact
-- SFX_Longsword_Special_Swing
-- SFX_Longsword_Steel_Charged_Swing
-- SFX_Longsword_Steel_Impact
-- SFX_Longsword_Steel_Swing
-- SFX_Lumbermill_Bench_Close
-- SFX_Lumbermill_Bench_Open
-- SFX_Lumbermill_Bench_Processing
-- SFX_Mace_T1_Block_Impact
-- SFX_Mace_T1_Impact
-- SFX_Mace_T1_Raise
-- SFX_Mace_T1_Raise_Local
-- SFX_Mace_T1_Shove
-- SFX_Mace_T1_Shove_Local
-- SFX_Mace_T1_Swing
-- SFX_Mace_T1_Swing_Charged
-- SFX_Mace_T1_Swing_Charged_LR_Local
-- SFX_Mace_T1_Swing_Charged_RL_Local
-- SFX_Mace_T1_Swing_Charged_Up_Local
-- SFX_Mace_T1_Swing_LR_Local
-- SFX_Mace_T1_Swing_RL_Local
-- SFX_Mace_T1_Swing_Up_Local
-- SFX_Mace_T2_Impact
-- SFX_Mace_T2_Raise
-- SFX_Mace_T2_Raise_Local
-- SFX_Mace_T2_Signature_Impact
-- SFX_Mace_T2_Signature_Impact_Local
-- SFX_Mace_T2_Signature_Launch
-- SFX_Mace_T2_Signature_Launch_Local
-- SFX_Mace_T2_Swing
-- SFX_Mace_T2_Swing_Charged
-- SFX_Mace_T2_Swing_Charged_LR_Local
-- SFX_Mace_T2_Swing_Charged_RL_Local
-- SFX_Mace_T2_Swing_Charged_Up_Local
-- SFX_Mace_T2_Swing_LR_Local
-- SFX_Mace_T2_Swing_RL_Local
-- SFX_Mace_T2_Swing_Up_Local
-- SFX_Meerkat_Alerted
-- SFX_Meerkat_Death
-- SFX_Meerkat_Hurt
-- SFX_Meerkat_Idle
-- SFX_Memories_Unlock_Local
-- SFX_Metal_Break
-- SFX_Metal_Build
-- SFX_Metal_Hit
-- SFX_Metal_Land
-- SFX_Metal_Walk
-- SFX_Moose_Bull_Alerted
-- SFX_Mouse_Alerted
-- SFX_Mouse_Death
-- SFX_Mouse_Flee
-- SFX_Mouse_Hurt
-- SFX_Mouse_Run
-- SFX_Mouse_Sleep
-- SFX_Mud_Break
-- SFX_Mud_Build
-- SFX_Mud_Hit
-- SFX_Mud_Land
-- SFX_Mud_Walk
-- SFX_Mug_Fill
-- SFX_Mug_Fill_Local
-- SFX_Mushroom_Break
-- SFX_Mushroom_Harvest
-- SFX_Music_Ducking_2db
-- SFX_NPC_Unarmed_Impact
-- SFX_NPC_Unarmed_Swing
-- SFX_Ore_Break
-- SFX_Ore_Hit
-- SFX_Outlander_Hunter_Arrow_Hit
-- SFX_Outlander_Hunter_Arrow_Miss
-- SFX_Outlander_Hurt
-- SFX_Owl_Alerted
-- SFX_Owl_Death
-- SFX_Owl_Hurt
-- SFX_Pickaxe_T1_Swing_Down_Local
-- SFX_Pickaxe_T2_Impact_Nice
-- SFX_Pig_Alerted
-- SFX_Pig_Death
-- SFX_Pig_Hurt
-- SFX_Pig_Run
-- SFX_Pig_Walk
-- SFX_Pigeon_Death
-- SFX_Pigeon_Hurt
-- SFX_Piglet_Alerted
-- SFX_Piglet_Death
-- SFX_Piglet_Hurt
-- SFX_Piglet_Run
-- SFX_Pistol_Fire
-- SFX_Plant_Break
-- SFX_Plant_Hit
-- SFX_Plant_MoveIn
-- SFX_Player_Climb_Down
-- SFX_Player_Climb_Side
-- SFX_Player_Climb_Up
-- SFX_Player_Craft_Item_Inventory
-- SFX_Player_Death
-- SFX_Player_Death_Drown
-- SFX_Player_Death_Fall
-- SFX_Player_Drop_Item
-- SFX_Player_Fall
-- SFX_Player_Glide_Motion
-- SFX_Player_Glide_Stationary
-- SFX_Player_Grab_Item
-- SFX_Player_Hurt
-- SFX_Player_Hurt_Burn
-- SFX_Player_Hurt_Drowning
-- SFX_Player_Hurt_Fall
-- SFX_Player_Jump
-- SFX_Player_Mantle
-- SFX_Player_Pickup_Item
-- SFX_Player_Roll
-- SFX_Player_Slide
-- SFX_Player_Swim
-- SFX_Player_Swim_Fast
-- SFX_Player_Swim_Jump
-- SFX_Player_Unarmed_Swing_Left
-- SFX_Player_Unarmed_Swing_Right
-- SFX_Plushie_Break
-- SFX_Plushie_Build
-- SFX_Poop_Bounce
-- SFX_Poop_Break
-- SFX_Poop_Hit
-- SFX_Poop_Walk
-- SFX_Portal_Neutral
-- SFX_Portal_Neutral_Open
-- SFX_Portal_Neutral_Teleport_Local
-- SFX_Portal_Void
-- SFX_Potion_Drink_Success
-- SFX_Processing_Placeholder
-- SFX_Projectile_Poop_Hit
-- SFX_Rabbit_Alerted
-- SFX_Rabbit_Death
-- SFX_Rabbit_Hurt
-- SFX_Rabbit_Run
-- SFX_Rabbit_Sleep
-- SFX_Ram_Alerted
-- SFX_Ram_Death
-- SFX_Ram_Hurt
-- SFX_Ram_Run
-- SFX_Ram_Sleep
-- SFX_Raptor_Cave_Alerted
-- SFX_Raptor_Cave_Idle
-- SFX_Rat_Death
-- SFX_Rat_Hurt
-- SFX_Raven_Alerted
-- SFX_Raven_Death
-- SFX_Raven_Flee
-- SFX_Raven_Hurt
-- SFX_Reeds_MoveIn
-- SFX_Rifle_Fire
-- SFX_Rifle_Fire_Local
-- SFX_Rope_Break
-- SFX_Rope_Build
-- SFX_Rope_Land
-- SFX_Rope_Walk
-- SFX_Rotate_Pitch_Default
-- SFX_Rotate_Roll_Default
-- SFX_Rotate_Yaw_Default
-- SFX_Rubble_Bounce
-- SFX_Rubble_Hit
-- SFX_Sand_Break
-- SFX_Sand_Build
-- SFX_Sand_Hit
-- SFX_Sand_Land
-- SFX_Sand_Walk
-- SFX_Scarak_Fighter_Alerted
-- SFX_Scarak_Fighter_Death
-- SFX_Scarak_Fighter_Hurt
-- SFX_Scarak_Seeker_Alerted
-- SFX_Scarak_Seeker_Death
-- SFX_Scarak_Seeker_Hurt
-- SFX_Scarak_Seeker_Spitball_Death
-- SFX_Scarak_Spitball_Fire
-- SFX_Scorpion_Alerted
-- SFX_Scorpion_Death
-- SFX_Scorpion_Run
-- SFX_Scorpion_Threaten
-- SFX_Seeds_Place
-- SFX_Shark_Death
-- SFX_Shark_Dive
-- SFX_Shark_Hurt
-- SFX_Shark_Swim
-- SFX_Shears_Activate
-- SFX_Sheep_Alerted
-- SFX_Sheep_Death
-- SFX_Sheep_Hurt
-- SFX_Sheep_Run
-- SFX_Sheep_Sheared
-- SFX_Sheep_Walk
-- SFX_Shield_T1_Break
-- SFX_Shield_T1_Impact
-- SFX_Shield_T1_Raise
-- SFX_Shield_T1_Raise_Local
-- SFX_Shield_T1_Swing
-- SFX_Shield_T1_Swing_Local
-- SFX_Shield_T2_Impact
-- SFX_Shield_T2_Raise
-- SFX_Shield_T2_Raise_Local
-- SFX_Shield_T2_Swing
-- SFX_Shield_T2_Swing_Local
-- SFX_Shovel_T1_Swing_RL_Local
-- SFX_Shovel_T2_Impact_Nice
-- SFX_Skeleton_Alerted
-- SFX_Skeleton_Death_1
-- SFX_Skeleton_Death_2
-- SFX_Skeleton_Death_3
-- SFX_Skeleton_Death_4
-- SFX_Skeleton_Despawn_1
-- SFX_Skeleton_Despawn_2
-- SFX_Skeleton_Hurt
-- SFX_Skeleton_Mage_Spellbook_Charge
-- SFX_Skeleton_Mage_Spellbook_Impact
-- SFX_Skeleton_Praetorian_Alerted
-- SFX_Skeleton_Praetorian_Death_1
-- SFX_Skeleton_Praetorian_Death_2
-- SFX_Skeleton_Praetorian_Death_3
-- SFX_Skeleton_Praetorian_Death_4
-- SFX_Skeleton_Praetorian_Despawn_1
-- SFX_Skeleton_Praetorian_Despawn_2
-- SFX_Skeleton_Praetorian_Hurt
-- SFX_Skeleton_Praetorian_Run
-- SFX_Skeleton_Praetorian_Search_2
-- SFX_Skeleton_Praetorian_Spawn_1
-- SFX_Skeleton_Praetorian_Walk
-- SFX_Skeleton_Run
-- SFX_Skeleton_Search_2
-- SFX_Skeleton_Spawn_1
-- SFX_Skeleton_Spawn_2
-- SFX_Skeleton_Walk
-- SFX_Snake_Alerted
-- SFX_Snake_Death
-- SFX_Snake_Hurt
-- SFX_Snake_Idle
-- SFX_Snow_Break
-- SFX_Snow_Build
-- SFX_Snow_Hit
-- SFX_Snow_Land
-- SFX_Snow_Walk
-- SFX_Soft_Break
-- SFX_Soft_Build
-- SFX_Soft_Hit
-- SFX_Soft_Land
-- SFX_Soft_Walk
-- SFX_Spark_Living_Alerted
-- SFX_Spark_Living_Death
-- SFX_Sparrow_Alerted
-- SFX_Sparrow_Death
-- SFX_Sparrow_Hurt
-- SFX_Sparrow_Idle
-- SFX_Spawn_Void_Alerted
-- SFX_Spawn_Void_Attack
-- SFX_Spawn_Void_Death
-- SFX_Spawn_Void_Hurt
-- SFX_Spawn_Void_Run
-- SFX_Spear_Impact
-- SFX_Spear_Lunge
-- SFX_Spear_Lunge_Local
-- SFX_Spear_Miss
-- SFX_Spear_Projectile_Impact
-- SFX_Spear_Throw
-- SFX_Spear_Throw_Charge
-- SFX_Spear_Throw_Charge_Local
-- SFX_Spear_Throw_Local
-- SFX_Spider_Alerted
-- SFX_Spider_Death
-- SFX_Spider_Run
-- SFX_Spirit_Root_Alerted
-- SFX_Spirit_Root_Death_01
-- SFX_Spirit_Root_Death_02
-- SFX_Spirit_Root_Hurt
-- SFX_Spirit_Root_Spawn
-- SFX_Squirrel_Alerted
-- SFX_Squirrel_Death
-- SFX_Squirrel_Hurt
-- SFX_Squirrel_Run
-- SFX_Staff_Charged_Loop
-- SFX_Staff_Fire_Shoot
-- SFX_Staff_Flame_Consume_Charge_1
-- SFX_Staff_Flame_Consume_Charge_1_Local
-- SFX_Staff_Flame_Consume_Charge_2
-- SFX_Staff_Flame_Consume_Charge_2_Local
-- SFX_Staff_Flame_Consume_Charge_3
-- SFX_Staff_Flame_Consume_Charge_3_Local
-- SFX_Staff_Flame_Consume_Charge_4
-- SFX_Staff_Flame_Consume_Charge_4_Local
-- SFX_Staff_Flame_Fireball_Impact
-- SFX_Staff_Flame_Fireball_Launch
-- SFX_Staff_Flame_Fireball_Launch_Local
-- SFX_Staff_Flame_Flamethrower
-- SFX_Staff_Flame_Flamethrower_End
-- SFX_Staff_Flame_Flamethrower_End_Local
-- SFX_Staff_Flame_Flamethrower_Impact
-- SFX_Staff_Flame_Flamethrower_Local
-- SFX_Staff_Flame_Trap_Deploy
-- SFX_Staff_Flame_Trap_Despawn
-- SFX_Staff_Flame_Trap_Loop
-- SFX_Staff_Ice_Shoot
-- SFX_Stamina_Potion_Success
-- SFX_Sticks_Break
-- SFX_Stone_Break
-- SFX_Stone_Build
-- SFX_Stone_Coffin_Open_Close
-- SFX_Stone_Harvest
-- SFX_Stone_Hit
-- SFX_Stone_Land
-- SFX_Stone_Walk
-- SFX_Sword_T1_Block_Local
-- SFX_Sword_T1_Lunge_Charge_Local
-- SFX_Sword_T1_Lunge_Local
-- SFX_Sword_T1_Shove_Local
-- SFX_Sword_T1_Swing_Down_Local
-- SFX_Sword_T1_Swing_LR_Local
-- SFX_Sword_T1_Swing_RL_Local
-- SFX_Sword_T2_Block_Local
-- SFX_Sword_T2_Impact
-- SFX_Sword_T2_Lunge_Charge_Local
-- SFX_Sword_T2_Lunge_Local
-- SFX_Sword_T2_Signature_Part_1
-- SFX_Sword_T2_Signature_Part_1_Local
-- SFX_Sword_T2_Signature_Part_2
-- SFX_Sword_T2_Signature_Part_2_Local
-- SFX_Sword_T2_Swing_Down_Local
-- SFX_Sword_T2_Swing_LR_Local
-- SFX_Sword_T2_Swing_RL_Local
-- SFX_T1_Impact_Blunt
-- SFX_Tall_Grass_MoveIn
-- SFX_Test_Blip_A
-- SFX_Test_Blip_B
-- SFX_Test_Blip_C
-- SFX_Tetrabird_Alerted
-- SFX_Tetrabird_Death
-- SFX_Tetrabird_Flee
-- SFX_Tetrabird_Hurt
-- SFX_Tetrabird_Run
-- SFX_Tiger_Sabertooth_Alerted
-- SFX_Tiger_Sabertooth_Death
-- SFX_Tiger_Sabertooth_Hurt
-- SFX_Tiger_Sabertooth_Run
-- SFX_Toad_Rhino_Alerted
-- SFX_Toad_Rhino_Death
-- SFX_Toad_Rhino_Hurt
-- SFX_Toad_Rhino_Magma_Alerted
-- SFX_Toad_Rhino_Magma_Death
-- SFX_Toad_Rhino_Magma_Hurt
-- SFX_Toad_Rhino_Magma_Run
-- SFX_Toad_Rhino_Magma_Tongue_Impact
-- SFX_Toad_Rhino_Magma_Tongue_Whoosh
-- SFX_Toad_Rhino_Run
-- SFX_Toad_Rhino_Tongue_Impact
-- SFX_Toad_Rhino_Tongue_Whoosh
-- SFX_Tombstone_Break
-- SFX_Tool_T1_Swing
-- SFX_Tool_Watering_Can_Water
-- SFX_Torch_Break
-- SFX_Torch_Build
-- SFX_Torch_Default_Loop
-- SFX_Torch_Impact
-- SFX_Torch_Off
-- SFX_Torch_On_Loop
-- SFX_Torch_Swing
-- SFX_Torch_Swing_Left_Local
-- SFX_Torch_Swing_Right_Local
-- SFX_Tornado
-- SFX_Trashpile_Land
-- SFX_Trashpile_Walk
-- SFX_Trork_Alerted
-- SFX_Trork_Chieftain_Alerted
-- SFX_Trork_Chieftain_Death
-- SFX_Trork_Chieftain_Hurt
-- SFX_Trork_Chieftain_Run
-- SFX_Trork_Chieftain_Search
-- SFX_Trork_Death
-- SFX_Trork_Exertion
-- SFX_Trork_Hurt_01
-- SFX_Trork_Hurt_02
-- SFX_Trork_Run
-- SFX_Trork_Search
-- SFX_Trork_Sleep
-- SFX_Trork_Throwing_Axe
-- SFX_Unarmed_Impact
-- SFX_Unarmed_Swing
-- SFX_Unbreakable_Block
-- SFX_Vulture_Alerted
-- SFX_Vulture_Death
-- SFX_Vulture_Flee
-- SFX_Vulture_Hurt
-- SFX_Wand_Fire_Shoot
-- SFX_Wand_Ice_Shoot
-- SFX_Warthog_Alerted
-- SFX_Warthog_Death
-- SFX_Warthog_Hurt
-- SFX_Warthog_Piglet_Alerted
-- SFX_Warthog_Piglet_Death
-- SFX_Warthog_Piglet_Hurt
-- SFX_Warthog_Piglet_Run
-- SFX_Warthog_Run
-- SFX_Warthog_Sleep
-- SFX_Warthog_Walk
-- SFX_Water_MoveIn
-- SFX_Water_MoveOut
-- SFX_Weapon_Bench_Close
-- SFX_Weapon_Bench_Craft
-- SFX_Weapon_Bench_Open
-- SFX_Weapon_Charge_Swing
-- SFX_Web_MoveIn
-- SFX_Window_Break
-- SFX_Window_Stone_Break
-- SFX_Wisp_Lamp_Loop
-- SFX_Wolf_Alerted
-- SFX_Wolf_Death
-- SFX_Wolf_Hurt
-- SFX_Wolf_Run
-- SFX_Wolf_Sleep
-- SFX_Wood_Break
-- SFX_Wood_Build
-- SFX_Wood_Hit
-- SFX_Wood_Land
-- SFX_Wood_Walk
-- SFX_Woodpecker_Death
-- SFX_Woodpecker_Hurt
-- SFX_Workbench_Close
-- SFX_Workbench_Craft
-- SFX_Workbench_Open
-- SFX_Workbench_Upgrade_Complete_Default
-- SFX_Workbench_Upgrade_Start_Default
-- SFX_Yeti_Alerted
-- SFX_Z1_Emit_Forest_Autumn_Day_Birds
-- SFX_Z1_Emit_Forest_Autumn_Day_Insects
-- SFX_Z1_Emit_Forest_Autumn_Day_Wind
-- SFX_Z1_Emit_Forest_Azure_Day_Insects
-- SFX_Z1_Emit_Forest_Azure_Day_Wind
-- SFX_Z1_Emit_Forest_Gen_Day_Birds
-- SFX_Z1_Emit_Forest_Gen_Day_Insects
-- SFX_Z1_Emit_Forest_Gen_Day_Winds
-- SFX_Z1_Emit_Forest_Moss_Day_Birds
-- SFX_Z1_Emit_Forest_Moss_Day_Insects
-- SFX_Z1_Emit_Forest_Moss_Day_Wind
-- SFX_Z1_Emit_Forest_Night_Birds
-- SFX_Z1_Emit_Forest_Night_Insects
-- SFX_Z1_Emit_Forest_Night_Wind
-- SFX_Z1_Emit_Kweebec_Village_Wind
-- SFX_Z1_Emit_Mountain_Day_Birds
-- SFX_Z1_Emit_Plains_Gen_Day_Birds
-- SFX_Z1_Emit_Plains_Gen_Day_Insects
-- SFX_Z1_Emit_Plains_Gen_Day_Wind
-- SFX_Z1_Emit_Plains_Gen_Night_Birds
-- SFX_Z1_Emit_Plains_Gen_Night_Insects
-- SFX_Z1_Emit_Plains_Gen_Night_Wind
-- SFX_Z1_Emit_Shore_Day_Birds
-- SFX_Z1_Emit_Shore_Waves
-- SFX_Z1_Emit_Shore_Wind
-- SFX_Z1_Emit_Swamp_Day_Birds
-- SFX_Z1_Emit_Swamp_Day_Frogs
-- SFX_Z1_Emit_Swamp_Day_Insects
-- SFX_Z1_Emit_Swamp_Day_Wind
-- SFX_Z1_Emit_Swamp_Night_Frogs
-- SFX_Z1_Emit_Trork_Camp
-- SFX_Z1_Shore_Day_Birds
-- SFX_Z3_Emit_Cave_Ice_Crackle
-- SFX_Z3_Emit_Cave_Ice_Rumble
-- SFX_Z3_Emit_Cave_Ice_Stress
-- SFX_Z3_Emit_Cave_Snow_Crackle
-- SFX_Z3_Emit_Cave_Snow_Melt
-- SFX_Z3_Emit_Hedera_FX
-- SFX_Z3_Emit_Hedera_PlantRustle
-- SFX_Z3_Emit_Tree_Creak
-- SFX_Z3_Emit_Wind_Leaves
-- SFX_Z3_Emit_Wind_Leaves_Stereo
-- SFX_Z3_Forest_Day_Birds
-- SFX_Z3_Forest_Day_General
-- SFX_Z3_Forest_Night_Birds
-- SFX_Zombie_Alerted
-- SFX_Zombie_Attack_Bite
-- SFX_Zombie_Attack_Swing
-- SFX_Zombie_Death
-- SFX_Zombie_Despawn
-- SFX_Zombie_Hurt
-- SFX_Zombie_Pursuit
-- SFX_Zombie_ScratchBack
-- SFX_Zombie_Spawn
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
diff --git a/content/docs/lt-LT/guides/ecs/entity-component-system.mdx b/content/docs/lt-LT/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/lt-LT/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/lt-LT/guides/ecs/example-ecs-plugin.mdx b/content/docs/lt-LT/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/lt-LT/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/lt-LT/guides/ecs/hytale-ecs-theory.mdx b/content/docs/lt-LT/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/lt-LT/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/lt-LT/guides/ecs/systems.mdx b/content/docs/lt-LT/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/lt-LT/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/lt-LT/guides/java-basics/00-introduction.mdx b/content/docs/lt-LT/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/lt-LT/guides/java-basics/00-introduction.mdx
+++ b/content/docs/lt-LT/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/lt-LT/guides/java-basics/06-methods-functions.mdx b/content/docs/lt-LT/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/lt-LT/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/lt-LT/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/lt-LT/guides/plugin/block-components.mdx b/content/docs/lt-LT/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/lt-LT/guides/plugin/browsing-serverjar.mdx b/content/docs/lt-LT/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/lt-LT/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/lt-LT/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/lt-LT/guides/plugin/build-and-test.mdx b/content/docs/lt-LT/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/lt-LT/guides/plugin/chat-formatting.mdx b/content/docs/lt-LT/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/lt-LT/guides/plugin/chat-formatting.mdx
+++ b/content/docs/lt-LT/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/lt-LT/guides/plugin/client-inputs-reference.mdx b/content/docs/lt-LT/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/lt-LT/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/lt-LT/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/lt-LT/guides/plugin/creating-block.mdx b/content/docs/lt-LT/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/lt-LT/guides/plugin/creating-block.mdx
+++ b/content/docs/lt-LT/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/lt-LT/guides/plugin/creating-commands.mdx b/content/docs/lt-LT/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/lt-LT/guides/plugin/creating-commands.mdx
+++ b/content/docs/lt-LT/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/lt-LT/guides/plugin/creating-configuration-file.mdx b/content/docs/lt-LT/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/lt-LT/guides/plugin/creating-events.mdx b/content/docs/lt-LT/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/lt-LT/guides/plugin/creating-events.mdx
+++ b/content/docs/lt-LT/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/lt-LT/guides/plugin/customizing-camera-controls.mdx b/content/docs/lt-LT/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/lt-LT/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/lt-LT/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/lt-LT/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/lt-LT/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/lt-LT/guides/plugin/instances.mdx b/content/docs/lt-LT/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/lt-LT/guides/plugin/inventory-management.mdx b/content/docs/lt-LT/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/lt-LT/guides/plugin/inventory-management.mdx
+++ b/content/docs/lt-LT/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/lt-LT/guides/plugin/item-interaction.mdx b/content/docs/lt-LT/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/lt-LT/guides/plugin/listening-to-packets.mdx b/content/docs/lt-LT/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/lt-LT/guides/plugin/logging.mdx b/content/docs/lt-LT/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/lt-LT/guides/plugin/player-death-event.mdx b/content/docs/lt-LT/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/lt-LT/guides/plugin/player-input-guide.mdx b/content/docs/lt-LT/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/lt-LT/guides/plugin/player-input-guide.mdx
+++ b/content/docs/lt-LT/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/lt-LT/guides/plugin/player-stats.mdx b/content/docs/lt-LT/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/lt-LT/guides/plugin/setting-up-env.mdx b/content/docs/lt-LT/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/lt-LT/guides/plugin/setting-up-env.mdx
+++ b/content/docs/lt-LT/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/lt-LT/guides/plugin/spawning-entities.mdx b/content/docs/lt-LT/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/lt-LT/guides/plugin/spawning-entities.mdx
+++ b/content/docs/lt-LT/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/lt-LT/guides/plugin/spawning-npcs.mdx b/content/docs/lt-LT/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/lt-LT/guides/plugin/store-persistant-data.mdx b/content/docs/lt-LT/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/lt-LT/guides/plugin/teleporting-players.mdx b/content/docs/lt-LT/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/lt-LT/guides/plugin/teleporting-players.mdx
+++ b/content/docs/lt-LT/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/lt-LT/guides/plugin/text-hologram.mdx b/content/docs/lt-LT/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/lt-LT/guides/plugin/ui.mdx b/content/docs/lt-LT/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/lt-LT/guides/plugin/world-gen.mdx b/content/docs/lt-LT/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/lt-LT/guides/plugin/world-gen.mdx
+++ b/content/docs/lt-LT/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/lt-LT/guides/prefabs.mdx b/content/docs/lt-LT/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/lt-LT/guides/prefabs.mdx
+++ b/content/docs/lt-LT/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/lt-LT/official-documentation/npc-doc.mdx b/content/docs/lt-LT/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/lt-LT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/lt-LT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/lt-LT/publishing/builtbybit.mdx b/content/docs/lt-LT/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/lt-LT/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/lt-LT/publishing/index.mdx b/content/docs/lt-LT/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/lt-LT/publishing/index.mdx
+++ b/content/docs/lt-LT/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/lv-LV/guides/ecs/entity-component-system.mdx b/content/docs/lv-LV/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..88a8c2d1
--- /dev/null
+++ b/content/docs/lv-LV/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Vienību Komponentu Sistēma
+description: Pamatu pamācība ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  Šī pamācība pieprasa pamata zināšanas OOP konceptiem, kā mantošana.
+
+  Lūdzu, pārliecinies, ka labi izproti šos konceptus pirms pamācības lasīšanas.
+</Callout>
+
+<Callout type="info">
+  Šī pamācība pašlaik ir tikai par ECS teoriju, un tajā nebūs koda piemēri.
+
+  Koda piemēri tiek apzināti izlaisti, lai izvairītos no neskaidrībām par to, kā ECS ieviests Hytale.
+</Callout>
+
+# Ievads
+
+Entity Component System, kas pazīstama arī kā ECS, ir dizaina modelis spēļu izstrādē.
+
+ECS sastāv no Vienībām, kas atsaucas uz komponentiem un sistēmām priekš vienībām.
+
+Tas arī koncentrējas uz kompozīciju pāri mantošanai, novēršot stingru hierarhiju un palīdz sadalīt uzvedību, datus, un atvieglo atkārtotu izmantošanu.
+
+# Kompozīcija Pāri Mantošanai
+
+Pirms saprotam kas ir ECS, jāsaprot kāda ir ECS filozofija.
+
+Mēs varam aprakstīt kompozīciju kā "tam ir X" un mantojumu kā "tas ir X".
+Kad mēs mantojam klasi Javā, mēs mantojam visus tās atribūtus un metodes.
+Kompozīcijā mēs varam izvēlēties katram objektam atsauces un kuras sistēmas ar to strādās.
+
+# Vienības, Komponenti un Sistēmas
+
+## Vienības
+
+Entity/Vienība ir unikāls identifikātors.
+
+- Tas nesatur datus.
+- Tas nesatur loģiku.
+
+Iedomājies vienības, kā lietvārdus, kas var būt aprakstīti izmantojot komponentus
+
+## Komponenti
+
+Komponenti ir prasti datu konteineri.
+
+- Tie glabā tikai datus
+- Tie nesatur uzvedību, vai loģiku
+- Tie apraksta vienību īpašības un aspektus
+
+Komponentu piemērs:
+
+- 'Position' komponents, kas glabā X, Y un Z koordinātes
+- 'Velocity' komponents, kas glabā ātrumu uz katras ass
+- 'Health' komponents, kas glabā pašreizējo vienības veselību
+
+Domā par komponentiem kā īpašības vārdiem, kas apraksta vienību
+
+## Sistēmas
+
+Sistēmas satur loģīku tavā spēlē (vai šajā gadījumā modā).
+
+- Tas darbojas uz visām vienībām, kam ir specifisks komponentu komplekts.
+- Tas neuzglabā vienību datus
+- Tas attiecina uzvedību lasot un modificējot komponentu datus
+
+Piemēram:
+
+- "WinConditionSystem" var apstrādāt Vienības, kas satur komponenta "Position" un "Velocity"
+- Ja vienība sasniedz `(0, 0, 0)` pozīciju, tad sistēma palaiž "Tu uzvarēji!" ziņu.
diff --git a/content/docs/lv-LV/guides/ecs/example-ecs-plugin.mdx b/content/docs/lv-LV/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..81930f81
--- /dev/null
+++ b/content/docs/lv-LV/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Parauga ECS Spraudnis
+description: Šajā pamācībā apgūsi kā veidot vienkāršu indes sistēmu, kas izmanto visas iepriekš apgūtās Hytale ECS funkcijas.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Praktisks Piemērs: Indes Sistēma
+
+Saliekot visu iepriekš apgūto kopā, šādi var pilnveidot indes sistēmu. Kad tā ir piešķirta vienībai, tā atņem dzīvības ar noteiktu intervālu līdz termiņa beigām un sevi noņem.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+Vaicājums izmanto tikai `poisonComponentType`, kas nozīmē, ka sistēma apstrādās jebkuru entītiju ar `PoisonComponent`, ne tikai spēlētājus. Tas padara to elastīgu NPC, pūļu vai jebkuras dzīvas būtnes saindēšanai. Sistēma ievieto sevi `GatherDamageGroup`, tāpēc bojājumi plūst caur pilnu bojājumu caurvadu, ieskaitot bruņu efektivitātes samazināšanu un neievainojamības pārbaudes.
diff --git a/content/docs/lv-LV/guides/ecs/hytale-ecs-theory.mdx b/content/docs/lv-LV/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/lv-LV/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/lv-LV/guides/ecs/systems.mdx b/content/docs/lv-LV/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/lv-LV/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/lv-LV/guides/java-basics/00-introduction.mdx b/content/docs/lv-LV/guides/java-basics/00-introduction.mdx
index 0256b529..d30974e2 100644
--- a/content/docs/lv-LV/guides/java-basics/00-introduction.mdx
+++ b/content/docs/lv-LV/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Pirms iedziļināmies programmēšanā, būs nepieciešami daži būtiski rīki,
 
 ### Java Development Kit (JDK)
 
-Lejuplādē un instalē JDK 25 vai jaunāku no [oficiālās Oracle saites](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) vai izmanto atvērta avota alternatīvu [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Integrētā Izstrādes Vide (IDE)
+### Integrated Development Environment (IDE)
 
 IDE ir lietojumprogramma, kas programmētājiem nodrošina visaptverošas iespējas programmatūras izstrādei. Populārākās Java izvēles ir šādas:
 
diff --git a/content/docs/lv-LV/guides/java-basics/01-variables.mdx b/content/docs/lv-LV/guides/java-basics/01-variables.mdx
index caf7db0b..fd33fcbb 100644
--- a/content/docs/lv-LV/guides/java-basics/01-variables.mdx
+++ b/content/docs/lv-LV/guides/java-basics/01-variables.mdx
@@ -18,10 +18,10 @@ Mainīgajam ir trīs galvenie komponenti:
 Pirms mainīgā lietošanas tas ir jādeklarē. Piemēram kaste ir jāizveido pirms tajā var kaut ko ielikt. Sintakse ir šāda:
 
 ```java
-int age; // A declaration
-age = 18; // An assignment
+int vecums; // Deklarēšana
+vecums = 18; // Noteikšana
 
-int age = 18; // Declaration and assignment in one line, also considered an initialization
+int vecums = 18; // Deklarēšana un vērtības noteikšana vienā līnijā, kas arī skaitās kā initializācija
 ```
 
 ## Datu Tipu Primitīvi:
diff --git a/content/docs/lv-LV/guides/java-basics/06-methods-functions.mdx b/content/docs/lv-LV/guides/java-basics/06-methods-functions.mdx
index e0aaecd9..3fb6ecf4 100644
--- a/content/docs/lv-LV/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/lv-LV/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String dabutVeselibasStatusu(int veseliba, int maxVeseliba) {
    * Satur vismaz vienu skaitli
    * Atgriež true, ja pareizi, savādāk false
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Bieži sastopamās kļūdas
 
 ```java
diff --git a/content/docs/lv-LV/guides/plugin/block-components.mdx b/content/docs/lv-LV/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/lv-LV/guides/plugin/browsing-serverjar.mdx b/content/docs/lv-LV/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/lv-LV/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/lv-LV/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/lv-LV/guides/plugin/build-and-test.mdx b/content/docs/lv-LV/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/lv-LV/guides/plugin/chat-formatting.mdx b/content/docs/lv-LV/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/lv-LV/guides/plugin/chat-formatting.mdx
+++ b/content/docs/lv-LV/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/lv-LV/guides/plugin/client-inputs-reference.mdx b/content/docs/lv-LV/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/lv-LV/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/lv-LV/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/lv-LV/guides/plugin/creating-block.mdx b/content/docs/lv-LV/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/lv-LV/guides/plugin/creating-block.mdx
+++ b/content/docs/lv-LV/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/lv-LV/guides/plugin/creating-commands.mdx b/content/docs/lv-LV/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/lv-LV/guides/plugin/creating-commands.mdx
+++ b/content/docs/lv-LV/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/lv-LV/guides/plugin/creating-configuration-file.mdx b/content/docs/lv-LV/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/lv-LV/guides/plugin/creating-events.mdx b/content/docs/lv-LV/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/lv-LV/guides/plugin/creating-events.mdx
+++ b/content/docs/lv-LV/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/lv-LV/guides/plugin/customizing-camera-controls.mdx b/content/docs/lv-LV/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/lv-LV/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/lv-LV/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/lv-LV/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/lv-LV/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/lv-LV/guides/plugin/instances.mdx b/content/docs/lv-LV/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/lv-LV/guides/plugin/inventory-management.mdx b/content/docs/lv-LV/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/lv-LV/guides/plugin/inventory-management.mdx
+++ b/content/docs/lv-LV/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/lv-LV/guides/plugin/item-interaction.mdx b/content/docs/lv-LV/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/lv-LV/guides/plugin/listening-to-packets.mdx b/content/docs/lv-LV/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/lv-LV/guides/plugin/logging.mdx b/content/docs/lv-LV/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/lv-LV/guides/plugin/player-death-event.mdx b/content/docs/lv-LV/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/lv-LV/guides/plugin/player-input-guide.mdx b/content/docs/lv-LV/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/lv-LV/guides/plugin/player-input-guide.mdx
+++ b/content/docs/lv-LV/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/lv-LV/guides/plugin/player-stats.mdx b/content/docs/lv-LV/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/lv-LV/guides/plugin/setting-up-env.mdx b/content/docs/lv-LV/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/lv-LV/guides/plugin/setting-up-env.mdx
+++ b/content/docs/lv-LV/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/lv-LV/guides/plugin/spawning-entities.mdx b/content/docs/lv-LV/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/lv-LV/guides/plugin/spawning-entities.mdx
+++ b/content/docs/lv-LV/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/lv-LV/guides/plugin/spawning-npcs.mdx b/content/docs/lv-LV/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/lv-LV/guides/plugin/store-persistant-data.mdx b/content/docs/lv-LV/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/lv-LV/guides/plugin/teleporting-players.mdx b/content/docs/lv-LV/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/lv-LV/guides/plugin/teleporting-players.mdx
+++ b/content/docs/lv-LV/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/lv-LV/guides/plugin/text-hologram.mdx b/content/docs/lv-LV/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/lv-LV/guides/plugin/ui.mdx b/content/docs/lv-LV/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/lv-LV/guides/plugin/world-gen.mdx b/content/docs/lv-LV/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/lv-LV/guides/plugin/world-gen.mdx
+++ b/content/docs/lv-LV/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/lv-LV/guides/prefabs.mdx b/content/docs/lv-LV/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/lv-LV/guides/prefabs.mdx
+++ b/content/docs/lv-LV/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/lv-LV/official-documentation/npc-doc.mdx b/content/docs/lv-LV/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/lv-LV/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/lv-LV/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/lv-LV/publishing/builtbybit.mdx b/content/docs/lv-LV/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/lv-LV/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/lv-LV/publishing/index.mdx b/content/docs/lv-LV/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/lv-LV/publishing/index.mdx
+++ b/content/docs/lv-LV/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/lv-LV/quick-start.mdx b/content/docs/lv-LV/quick-start.mdx
index 6324ad80..872472a9 100644
--- a/content/docs/lv-LV/quick-start.mdx
+++ b/content/docs/lv-LV/quick-start.mdx
@@ -3,9 +3,9 @@ title: Īsa Pamācība
 description: Standarta Hytale projekta izveide.
 ---
 
-Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+Sveicināts Hytale Modding dokumentācijā! Šeit atradīsi visu, kas vajadzīgs savu modifikāciju veidošanai priekš Hytale.
 
-* [Java Basics](./guides/java-basics/00-introduction)
-* [Setting up your dev environment](./guides/plugin/setting-up-env)
-* [Entity Component System (ECS)](./guides/ecs)
-* [Publishing your mod](./guides/publishing)
+* [Java Pamati](./guides/java-basics/00-introduction)
+* [Darba vides uzstādīšana](./guides/plugin/setting-up-env)
+* [Entity/Vienību Komponentu Sistēma(ECS)](./guides/ecs)
+* [Modifikāciju publicēšana](./guides/publishing)
diff --git a/content/docs/nl-NL/guides/ecs/entity-component-system.mdx b/content/docs/nl-NL/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/nl-NL/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/nl-NL/guides/ecs/example-ecs-plugin.mdx b/content/docs/nl-NL/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/nl-NL/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/nl-NL/guides/ecs/hytale-ecs-theory.mdx b/content/docs/nl-NL/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/nl-NL/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/nl-NL/guides/ecs/systems.mdx b/content/docs/nl-NL/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/nl-NL/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/nl-NL/guides/java-basics/00-introduction.mdx b/content/docs/nl-NL/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/nl-NL/guides/java-basics/00-introduction.mdx
+++ b/content/docs/nl-NL/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/nl-NL/guides/java-basics/06-methods-functions.mdx b/content/docs/nl-NL/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/nl-NL/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/nl-NL/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/nl-NL/guides/plugin/block-components.mdx b/content/docs/nl-NL/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/nl-NL/guides/plugin/browsing-serverjar.mdx b/content/docs/nl-NL/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/nl-NL/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/nl-NL/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/nl-NL/guides/plugin/build-and-test.mdx b/content/docs/nl-NL/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/nl-NL/guides/plugin/chat-formatting.mdx b/content/docs/nl-NL/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/nl-NL/guides/plugin/chat-formatting.mdx
+++ b/content/docs/nl-NL/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/nl-NL/guides/plugin/client-inputs-reference.mdx b/content/docs/nl-NL/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/nl-NL/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/nl-NL/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/nl-NL/guides/plugin/creating-block.mdx b/content/docs/nl-NL/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/nl-NL/guides/plugin/creating-block.mdx
+++ b/content/docs/nl-NL/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/nl-NL/guides/plugin/creating-commands.mdx b/content/docs/nl-NL/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/nl-NL/guides/plugin/creating-commands.mdx
+++ b/content/docs/nl-NL/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/nl-NL/guides/plugin/creating-configuration-file.mdx b/content/docs/nl-NL/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/nl-NL/guides/plugin/creating-events.mdx b/content/docs/nl-NL/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/nl-NL/guides/plugin/creating-events.mdx
+++ b/content/docs/nl-NL/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/nl-NL/guides/plugin/customizing-camera-controls.mdx b/content/docs/nl-NL/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/nl-NL/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/nl-NL/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/nl-NL/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/nl-NL/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/nl-NL/guides/plugin/instances.mdx b/content/docs/nl-NL/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/nl-NL/guides/plugin/inventory-management.mdx b/content/docs/nl-NL/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/nl-NL/guides/plugin/inventory-management.mdx
+++ b/content/docs/nl-NL/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/nl-NL/guides/plugin/item-interaction.mdx b/content/docs/nl-NL/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/nl-NL/guides/plugin/listening-to-packets.mdx b/content/docs/nl-NL/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/nl-NL/guides/plugin/logging.mdx b/content/docs/nl-NL/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/nl-NL/guides/plugin/player-death-event.mdx b/content/docs/nl-NL/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/nl-NL/guides/plugin/player-input-guide.mdx b/content/docs/nl-NL/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/nl-NL/guides/plugin/player-input-guide.mdx
+++ b/content/docs/nl-NL/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/nl-NL/guides/plugin/player-stats.mdx b/content/docs/nl-NL/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/nl-NL/guides/plugin/setting-up-env.mdx b/content/docs/nl-NL/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/nl-NL/guides/plugin/setting-up-env.mdx
+++ b/content/docs/nl-NL/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/nl-NL/guides/plugin/spawning-entities.mdx b/content/docs/nl-NL/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/nl-NL/guides/plugin/spawning-entities.mdx
+++ b/content/docs/nl-NL/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/nl-NL/guides/plugin/spawning-npcs.mdx b/content/docs/nl-NL/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/nl-NL/guides/plugin/store-persistant-data.mdx b/content/docs/nl-NL/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/nl-NL/guides/plugin/teleporting-players.mdx b/content/docs/nl-NL/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/nl-NL/guides/plugin/teleporting-players.mdx
+++ b/content/docs/nl-NL/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/nl-NL/guides/plugin/text-hologram.mdx b/content/docs/nl-NL/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/nl-NL/guides/plugin/ui.mdx b/content/docs/nl-NL/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/nl-NL/guides/plugin/world-gen.mdx b/content/docs/nl-NL/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/nl-NL/guides/plugin/world-gen.mdx
+++ b/content/docs/nl-NL/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/nl-NL/guides/prefabs.mdx b/content/docs/nl-NL/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/nl-NL/guides/prefabs.mdx
+++ b/content/docs/nl-NL/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/nl-NL/official-documentation/npc-doc.mdx b/content/docs/nl-NL/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/nl-NL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/nl-NL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/nl-NL/publishing/builtbybit.mdx b/content/docs/nl-NL/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/nl-NL/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/nl-NL/publishing/index.mdx b/content/docs/nl-NL/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/nl-NL/publishing/index.mdx
+++ b/content/docs/nl-NL/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/pl-PL/guides/ecs/entity-component-system.mdx b/content/docs/pl-PL/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/pl-PL/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/pl-PL/guides/ecs/example-ecs-plugin.mdx b/content/docs/pl-PL/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/pl-PL/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/pl-PL/guides/ecs/hytale-ecs-theory.mdx b/content/docs/pl-PL/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/pl-PL/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/pl-PL/guides/ecs/systems.mdx b/content/docs/pl-PL/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/pl-PL/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/pl-PL/guides/java-basics/00-introduction.mdx b/content/docs/pl-PL/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/pl-PL/guides/java-basics/00-introduction.mdx
+++ b/content/docs/pl-PL/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/pl-PL/guides/java-basics/06-methods-functions.mdx b/content/docs/pl-PL/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/pl-PL/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/pl-PL/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/pl-PL/guides/plugin/block-components.mdx b/content/docs/pl-PL/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/pl-PL/guides/plugin/browsing-serverjar.mdx b/content/docs/pl-PL/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/pl-PL/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/pl-PL/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/pl-PL/guides/plugin/build-and-test.mdx b/content/docs/pl-PL/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/pl-PL/guides/plugin/chat-formatting.mdx b/content/docs/pl-PL/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/pl-PL/guides/plugin/chat-formatting.mdx
+++ b/content/docs/pl-PL/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/pl-PL/guides/plugin/client-inputs-reference.mdx b/content/docs/pl-PL/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/pl-PL/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/pl-PL/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/pl-PL/guides/plugin/creating-block.mdx b/content/docs/pl-PL/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/pl-PL/guides/plugin/creating-block.mdx
+++ b/content/docs/pl-PL/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/pl-PL/guides/plugin/creating-commands.mdx b/content/docs/pl-PL/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/pl-PL/guides/plugin/creating-commands.mdx
+++ b/content/docs/pl-PL/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/pl-PL/guides/plugin/creating-configuration-file.mdx b/content/docs/pl-PL/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/pl-PL/guides/plugin/creating-events.mdx b/content/docs/pl-PL/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/pl-PL/guides/plugin/creating-events.mdx
+++ b/content/docs/pl-PL/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/pl-PL/guides/plugin/customizing-camera-controls.mdx b/content/docs/pl-PL/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/pl-PL/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/pl-PL/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/pl-PL/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/pl-PL/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/pl-PL/guides/plugin/instances.mdx b/content/docs/pl-PL/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/pl-PL/guides/plugin/inventory-management.mdx b/content/docs/pl-PL/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/pl-PL/guides/plugin/inventory-management.mdx
+++ b/content/docs/pl-PL/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/pl-PL/guides/plugin/item-interaction.mdx b/content/docs/pl-PL/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/pl-PL/guides/plugin/listening-to-packets.mdx b/content/docs/pl-PL/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/pl-PL/guides/plugin/logging.mdx b/content/docs/pl-PL/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/pl-PL/guides/plugin/player-death-event.mdx b/content/docs/pl-PL/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/pl-PL/guides/plugin/player-input-guide.mdx b/content/docs/pl-PL/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/pl-PL/guides/plugin/player-input-guide.mdx
+++ b/content/docs/pl-PL/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/pl-PL/guides/plugin/player-stats.mdx b/content/docs/pl-PL/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/pl-PL/guides/plugin/setting-up-env.mdx b/content/docs/pl-PL/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/pl-PL/guides/plugin/setting-up-env.mdx
+++ b/content/docs/pl-PL/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/pl-PL/guides/plugin/spawning-entities.mdx b/content/docs/pl-PL/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/pl-PL/guides/plugin/spawning-entities.mdx
+++ b/content/docs/pl-PL/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/pl-PL/guides/plugin/spawning-npcs.mdx b/content/docs/pl-PL/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/pl-PL/guides/plugin/store-persistant-data.mdx b/content/docs/pl-PL/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/pl-PL/guides/plugin/teleporting-players.mdx b/content/docs/pl-PL/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/pl-PL/guides/plugin/teleporting-players.mdx
+++ b/content/docs/pl-PL/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/pl-PL/guides/plugin/text-hologram.mdx b/content/docs/pl-PL/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/pl-PL/guides/plugin/ui.mdx b/content/docs/pl-PL/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/pl-PL/guides/plugin/world-gen.mdx b/content/docs/pl-PL/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/pl-PL/guides/plugin/world-gen.mdx
+++ b/content/docs/pl-PL/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/pl-PL/guides/prefabs.mdx b/content/docs/pl-PL/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/pl-PL/guides/prefabs.mdx
+++ b/content/docs/pl-PL/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/pl-PL/official-documentation/npc-doc.mdx b/content/docs/pl-PL/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/pl-PL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/pl-PL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/pl-PL/publishing/builtbybit.mdx b/content/docs/pl-PL/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/pl-PL/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/pl-PL/publishing/index.mdx b/content/docs/pl-PL/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/pl-PL/publishing/index.mdx
+++ b/content/docs/pl-PL/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/pt-BR/contributing/pr-guidelines.mdx b/content/docs/pt-BR/contributing/pr-guidelines.mdx
index 329468c8..6f5625b7 100644
--- a/content/docs/pt-BR/contributing/pr-guidelines.mdx
+++ b/content/docs/pt-BR/contributing/pr-guidelines.mdx
@@ -1,39 +1,39 @@
 ---
-title: PR Guidelines
-description: Guidelines that reviewers and contributors should follow when submitting and reviewing pull requests.
+title: Orientações de pull request
+description: Orientações que revisores e contribuidores devem seguir ao enviarem e analisarem os pull requests.
 ---
 
-# Pull Request Guidelines
+# Introdução
 
-To ensure a smooth and efficient review process, both contributors and reviewers should adhere to the following guidelines when submitting and reviewing pull requests (PRs).
+Para garantir um processo de revisão suave e eficiente, tanto os contribuidores quantos os revisores devem aderir às orientações ao enviar e analisar os pull requests. Veja abaixo:
 
-## For Contributors
+## Para os contribuidores
 
-1. **Descriptive Titles and Descriptions**
-   - Use clear and concise titles that summarize the changes.
-   - Provide detailed descriptions of what the PR does, why the changes are necessary, and any relevant context.
-2. **Link to Issues**
-   - In your PR title, add `GH-ISSUE-NUMBER` to link the PR to the relevant issue. This is required for all PRs.
-3. **Small, Focused Changes**
-   - Aim to keep PRs small and focused on a single issue or feature. This makes it easier for reviewers to understand and provide feedback.
-4. **Code Quality**
-   - Ensure your code follows the project's coding standards and best practices.
-   - Include comments where necessary to explain complex logic.
-5. **Testing**
-   - Test your changes thoroughly before submitting the PR.
-   - If applicable, include unit tests or integration tests to verify your changes.
+1. **Títulos e descrições descritivas**
+   - Use títulos coerentes e concisos que resumam as alterações;
+   - Descreva detalhadamente as ações do pull request, a necessidade das mudanças e o contexto relevante.
+2. **Link para problemas**
+   - No título do seu pull request, adicione `GH-ISSUE-NUMBER` para vinculá-lo ao problema correspondente. Isso é necessário para todos os pull requests.
+3. **Mudanças pequenas e focadas**
+   - Procure manter os pull requests pequenos e focados em um único problema ou recurso. Isso ajuda os revisores a entenderem melhor e a oferecerem feedback.
+4. **Qualidade do código**
+   - Certifique-se de que seu código siga os padrões e as práticas recomendadas de codificação do projeto;
+   - Inclua comentários quando necessário para explicar a lógica complexa.
+5. **Testando**
+   - Teste as suas alterações cuidadosamente antes de enviar o pull request;
+   - Se aplicável, inclua testes unitários ou de integração para verificar as suas alterações.
 6. **Documentação**
-   - Update or add documentation as needed to reflect your changes.
-7. **Commit Messages**
-   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
-8. **Check for Conflicts**
-   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+   - Atualize ou adicione documentação conforme necessário para refletir em suas alterações.
+7. **Mensagens de commit**
+   - Siga o formato [convencional de commits](https://www.conventionalcommits.org/en/v1.0.0/) para criar mensagens de commit claras e descritivas.
+8. **Verificar se há conflitos**
+   - Antes de enviar seu PR, certifique-se de que a sua branch esteja atualizada com a branch base para minimizar conflitos de mesclagem.
 
-## For Reviewers
+## Para os revisores
 
-- You are supposed to review PRs thoroughly, and request changes if needed.
-- Provide constructive feedback and suggestions for improvement.
-- Verify that the changes meet the project's coding standards and best practices.
-- Deploy the PR using the dokploy integration to ensure the changes work as expected.
-- Ensure that documentation is updated as necessary.
-- Approve the PR only when you are satisfied with the changes and all checks have passed.
+- Você deve revisar os pull requests minuciosamente e, se necessário, solicitar alterações;
+- Forneça feedbacks construtivos e sugestões de melhoria;
+- Verifique se as mudanças estão em conformidade com o código e as boas práticas do projeto;
+- Faça a implementação do pull request utilizando a integração com o Dokploy para garantir que as alterações funcionem conforme o esperado;
+- Mantenha a documentação atualizada segundo as necessidades das alterações;
+- Aprove o pull request apenas quando estiver satisfeito com as alterações e todas as verificações tiverem passado.
diff --git a/content/docs/pt-BR/contributing/writing-guides.mdx b/content/docs/pt-BR/contributing/writing-guides.mdx
index 42367147..f91f9488 100644
--- a/content/docs/pt-BR/contributing/writing-guides.mdx
+++ b/content/docs/pt-BR/contributing/writing-guides.mdx
@@ -1,86 +1,86 @@
 ---
-title: Writing Guides
+title: Escrevendo guias
 ---
 
-## Creating a guide file
+## Criando um arquivo de guia
 
-To start writing a guide, you need to create a file with extension `.mdx`. You need to create this file inside the `/content/docs/en` directory, now it depends in which section you want to make the guide, so you can decide which folder you should put it in after that.
+Para começar a escrever um guia, crie um arquivo com a extensão `.mdx`. Crie esse arquivo dentro do diretório `/content/docs/en`. O local exato dependerá da seção onde deseja incluir o guia. Por isso, escolha a pasta apropriada após esse caminho.
 
-Suppose I want to make a java basics guide, I'd put it in `/content/docs/en/guides/java-basics`. You'll have to do some digging to find out where you want to place it.
+Suponha que eu queira criar um guia de fundamentos do Java, então eu o colocaria em `/content/docs/en/guides/java-basics`. Você precisará investigar um pouco para descobrir onde deseja colocá-lo.
 
 <Callout>
-  If there's already a guide in the section you want to write about, you can just press on the "Edit On GitHub" button on our website and it'll take you to the folder, now you can write in the same folder to have your guide appear in the same section.
+  Se já houver um guia na seção sobre a qual você deseja escrever, basta clicar no botão "Edit On GitHub" em nosso site. Isso levará você diretamente à pasta correta. Salve seu novo guia nela para que ele apareça na mesma seção.
 </Callout>
 
 ## Frontmatter
 
-Frontmatter is the metadata of your guide, it tells our website how to display your guide. This needs to be at the very top of the file, which starts with `---` and ends with `---`.
+O frontmatter representa os metadados do seu guia. Ele informa ao nosso site como o conteúdo deve ser mostrado. Isso precisa estar no topo do arquivo, que começa com `---` e termina com `---`.
 
-Here's an example:
+Veja um exemplo abaixo:
 
 ```mdx
 ---
-title: "Java Basics"
-description: "Learn the basics of Java programming."
+title: "Fundamentos do Java"
+description: "Aprenda os conceitos básicos de programação em Java."
 authors:
-    - name: "Your Name"
-      url: "https://yourwebsite.com"
+    - name: "Seu nome"
+      url: "https://seusite.com"
 ---
 ```
 
-Now as you can see, it's pretty self explanatory, you just need to fill in the details for your specific guide. If you don't have a URL you want to link yourself to, just don't write that whole line. Additionally, the authors section is optional, so if you don't want to add it, you can just leave it out although we encourage you to do so and credit yourself.
+Como você pode ver, é bastante autoexplicativo. Basta preencher os detalhes para o seu guia específico. Caso não tenha uma URL para pôr naquele espaço, deixe-o em branco. A seção de autores é opcional. Se preferir, você pode omiti-la, mas recomendamos que a utilize para se identificar como autor do guia para obter os devidos créditos.
 
-The indentation in the frontmatter is important, so make sure to keep it consistent with the example.
+A indentação no frontmatter é fundamental. Garanta que os espaços estejam exatamente como no exemplo.
 
-## Content Structure
+## Estrutura do conteúdo
 
-You should structure the content of your guide in a clear and organized manner. Here are some tips on how to do that:
+Você deve estruturar o conteúdo do seu guia com clareza e organização. Veja abaixo algumas dicas de como fazer isso:
 
-- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
-- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
-- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
-- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
-- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+- **Introdução:** comece com uma visão geral do tópico e o que o leitor pode esperar aprender;
+- **Pré-requisitos:** liste quaisquer pré-requisitos ou conhecimentos prévios que o leitor deva ter antes de se aprofundar no guia;
+- **Etapas das instruções:** divida o conteúdo em etapas claras e objetivas. Use títulos e subtítulos para organizar as informações;
+- **Exemplos de código:** inclua trechos de código para ilustrar os principais pontos. Certifique-se de explicar cada exemplo de forma detalhada;
+- **Conclusão:** resuma os principais pontos e incentive o leitor a explorar mais ou a colocar em prática o que aprendeu.
 
-Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+Se você estiver escrevendo uma seção muito extensa, o ideal é dividi-la em várias páginas para que a informação seja mais fácil de ser entendida. Ninguém quer ler um enorme bloco de texto de uma só vez!
 
-When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+Ao escrever guias, devemos pensar em como as pessoas os consumirão e muitas preferem passar rapidamente pelo conteúdo em vez de lê-lo em detalhes. É por isso que é melhor dividir a informação em várias páginas, para que o conteúdo pareça menos denso para o leitor. Além disso, considere usar tópicos, listas numeradas e outras técnicas de formatação para tornar o conteúdo mais amigável.
 
-## Formatting
+## Formatação
 
-We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+Utilizamos [Markdown](https://www.markdownguide.org/) para formatar os nossos guias. A seguir estão alguns pontos importantes a serem considerados:
 
-- Use headings (`#`, `##`, `###`) to organize your content.
-- Use bullet points and numbered lists for clarity.
-- Use code blocks (\`\`\`) for code snippets.
-- Use links to reference other guides or external resources.
+- Use títulos (`#`, `##`, `###`) para organizar o seu conteúdo;
+- Use listas com marcadores e listas numeradas para maior clareza;
+- Use blocos de código (\`\`\`) para trechos de código;
+- Use links para referenciar outros guias ou recursos externos.
 
-This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+Esse é o mesmo tipo de formatação que você verá na maioria dos sites de documentação e também em plataformas sociais, como o Discord.
 
-You can also make a Callout to highlight important information or tips. Use the following syntax:
+Você também pode usar um callout para destacar informações ou dicas importantes. Use a seguinte sintaxe:
 
 ```mdx
 <Callout>
-    This is a callout message.
+    Esta é uma mensagem em destaque de callout.
 </Callout>
 ```
 
 <Callout>
-  This is a callout message.
+  Esta é uma mensagem em destaque usando callout.
 </Callout>
 
 Você pode alterar a cor do callout adicionando um atributo `type`. Por exemplo:
 
 ```mdx
 <Callout type="info">
-    This is an info callout.
+    Isto é um callout de informação
 </Callout>
 ```
 
-Available types are: `info`, `warning`, `error`, and `success`.
+Os tipos disponíveis são: `info`, `warning`,  `error`  e `success`.
 
 ## Conclusão
 
-That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+Isso é tudo! Agora você é um mestre em escrever guias. Não se preocupe em ter um inglês perfeito. Escreva o guia como se estivesse explicando o assunto para alguém e não hesite em pedir feedback ou ajuda se precisar.
 
-Happy writing!
+Boa escrita!
diff --git a/content/docs/pt-BR/established-information/developer-qa-insights.mdx b/content/docs/pt-BR/established-information/developer-qa-insights.mdx
index 47915c97..8b18c9b5 100644
--- a/content/docs/pt-BR/established-information/developer-qa-insights.mdx
+++ b/content/docs/pt-BR/established-information/developer-qa-insights.mdx
@@ -1,25 +1,25 @@
 ---
-title: Developer Q&A Technical Insights
-description: Comprehensive summary of technical insights from Hytale developers covering architecture, modding, gameplay systems, and development philosophy.
+title: Perguntas e respostas técnicas de desenvolvedor
+description: Compilado técnico detalhado dos desenvolvedores do Hytale sobre arquitetura, criação de mods, sistemas do jogo e a filosofia de desenvolvimento.
 ---
 
-# Developer Q&A Technical Insights
+# Introdução
 
-This extensive Q&A session with Hytale developers reveals critical technical details about the game's architecture, modding philosophy, gameplay systems, and development approach.
+Esta extensa sessão de perguntas e respostas com os desenvolvedores do Hytale revela detalhes técnicos críticos sobre a arquitetura do jogo, filosofia da criação de mods, sistemas de jogabilidade e abordagem de desenvolvimento.
 
-## Technical Architecture
+## Arquitetura técnica
 
-### Network & Infrastructure
+### Rede e infraestrutura
 
-* **Protocol**: Uses QUIC (reliable UDP with unreliable channels) instead of TCP
-* **Server Compatibility**: Runs on any platform supporting Java 25
-* **Connection Method**: Direct IP initially, server discovery planned post-launch
-* **Data Layer**: Current custom serialization format will be replaced post-launch
-* **Performance**: Multi-core support - each world has main thread + parallel execution
-* **Rendering**: OpenGL 3.3 for Mac compatibility, potential future Vulkan/Metal migration
-* **Tick Model**: Base server tick rate is 30 TPS by default; can be changed using server plugins.
+* **Protocolo**: usa QUIC (UDP confiável com canais não confiáveis) em vez de TCP;
+* **Compatibilidade de servidor**: funciona em qualquer plataforma que suporte Java 25;
+* **Método de conexão**: inicialmente por IP direto. A listagem de servidores será planejada após o lançamento;
+* **Camada de dados**: o formato de serialização personalizada atual será substituído pós-lançamento;
+* **Desempenho**: suporte a múltiplos núcleos, e cada mundo tem um thread principal + execução paralela;
+* **Renderização**: OpenGL 3.3 para compatibilidade com Mac, potencial migração para Vulkan/Metal;
+* **Modelo de tick**: a taxa de atualização base do servidor é de 30 TPS por padrão. e pode ser alterada através de plugins de servidor.
 
-### Security & Distribution
+### Segurança e distribuição
 
 * **No Client-Side Code Execution**: Prevents remote code execution exploits
 * **Downloads Limited To**: Configuration files and assets only
@@ -28,7 +28,7 @@ This extensive Q&A session with Hytale developers reveals critical technical det
 
 ## Modding Capabilities
 
-### Server-Side Power
+### Poder do server-side
 
 * **Full Java Access**: Database connections, web requests, any Java functionality
 * **Custom Libraries**: Can create Lua scripting, ML frameworks, or any Java library
@@ -44,7 +44,7 @@ This extensive Q&A session with Hytale developers reveals critical technical det
 * **Visual Scripting**: Replaces command blocks, fully sandboxed
 * **Prefab System**: Sophisticated building blocks with in-game editor
 
-### Advanced Modding
+### Criação de mods avançada
 
 * **Combat System**: Data-driven interaction system for attack chains and abilities
 * **Sub-Hitboxes**: Support for complex boss mechanics (needs improvement)
@@ -52,9 +52,9 @@ This extensive Q&A session with Hytale developers reveals critical technical det
 * **Custom UI**: NoesisGUI transition enables powerful interface customization
 * **Block Physics**: Selective system (trees fall, but placed blocks don't)
 
-## Gameplay Systems
+## Sistemas de jogabilidade
 
-### Core Mechanics
+### Principais mecânicas
 
 * **Stamina System**: No hunger by default (can be modded in)
 * **Gravity**: Selective block physics - trees collapse, buildings can float
@@ -62,44 +62,44 @@ This extensive Q&A session with Hytale developers reveals critical technical det
 * **World Height**: Currently limited, may change with voxel storage updates
 * **Automation**: No redstone equivalent at launch (moddable)
 
-### Player Systems
+### Sistemas de jogador
 
 * **Character Models**: Humans by default, changeable in creative mode
 * **Multiplayer Avatars**: Server-controlled (no custom models in multiplayer)
 * **Skins**: Full customization possible ("mod yourself into a potato")
 * **Shapeshifting**: Transformation potions exist for fun/modding
 
-### World & NPCs
+### Mundo e NPCs
 
 * **Faction System**: Living world with dynamic NPC interactions
 * **Village Systems**: Planned dynamic villages with relationships and behaviors
 * **Chunk Loading**: Entities unload when out of all players' render distance
 * **Seeds**: Shareable world generation seeds supported
 
-## Development Philosophy
+## Filosofia de desenvolvimento
 
-### Release Strategy
+### Estratégia de lançamento
 
 * **Base Game Priority**: Adventure mode is primary focus, modding architecture supports it
 * **Tech Debt**: Acknowledged as necessary for release, commitment to improvement
 * **Update Frequency**: Very frequent updates planned, especially post-launch
 * **Version Policy**: Always latest version, but servers can run modified versions
 
-### Community Focus
+### Foco na comunidade
 
 * **Creator Support**: Development bounties planned for community contributors
 * **Tutorials**: Official modding tutorials planned with partners
 * **Feedback Integration**: Strong commitment to community-driven improvements
 * **Accessibility**: Designed for lower-end hardware, reasonable system requirements
 
-### Tools & Documentation
+### Ferramentas e documentação
 
 * **Blockbench Integration**: Replaces custom "Hytale Model Maker"
 * **Machinima Tools**: Full cinematic creation capabilities
 * **Creative Tools**: Major reveal planned for building/creation features
 * **Source Access**: Server code will be unobfuscated with developer comments
 
-## Platform Support
+## Plataforma(s) compatível(is)
 
 * **Current**: Windows (primary)
 * **Planned**: Mac/Linux support actively in development
@@ -107,14 +107,14 @@ This extensive Q&A session with Hytale developers reveals critical technical det
 * **Performance**: Uncapped framerate, designed for accessibility
 * **Offline Play**: Single-player works without internet connection
 
-## Monetization & Legal
+## Monetização e jurídico
 
 * **No Pay-to-Win**: Firm commitment against P2W mechanics
 * **Cosmetics Only**: Low-price cosmetic packs to support infrastructure
 * **Server EULA**: Terms being finalized for server monetization policies
 * **QUIC Blocking**: Acknowledged issue in some regions, no alternative protocol
 
-## Current Limitations
+## Limitações
 
 * **Custom Shaders**: Not supported until sandboxing solution found
 * **UI/Input Limitations**: Being expanded but currently restricted
diff --git a/content/docs/pt-BR/established-information/gameplay/creative.mdx b/content/docs/pt-BR/established-information/gameplay/creative.mdx
index 889d4adc..e9b9fe35 100644
--- a/content/docs/pt-BR/established-information/gameplay/creative.mdx
+++ b/content/docs/pt-BR/established-information/gameplay/creative.mdx
@@ -9,9 +9,9 @@ description: Informações sobre o modo criativo no Hytale.
 
 ## Ferramentas de edição do mundo
 
-Creative mode includes a variety of tools to help players edit the world. It includes undo functionality for edits.
+Há diversas ferramentas que ajudarão os jogadores a editar o mundo ao usarem o modo Criativo. Além de construir, é possível desfazer as edições.
 
-Note that the below sections were unnamed in the video demo of the tools.
+Observe que os tópicos abaixo não foram nomeados no vídeo demonstrativo das ferramentas.
 
 ---
 
@@ -49,7 +49,7 @@ Allows the user to measure distances between multiple points in 3D space, with s
 
 ### Layer Brush Tool
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
 ### Paste Tool
 
@@ -136,7 +136,7 @@ Desconhecido até dezembro de 2025.
 
 ## Configurações rápidas do modo criativo
 
-Note that these are WIP and subject to change. **Atualmente, nem todas as configurações e funcionalidades são conhecidas**.
+Veja que estas ferramentas estão em desenvolvimento e estão sujeitas a mudanças. **Atualmente, nem todas as configurações e funcionalidades são conhecidas**.
 
 - Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
 - Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
@@ -154,29 +154,29 @@ Note that these are WIP and subject to change. **Atualmente, nem todas as config
 - No Clip (Toggle): Description unknown as of December 2025.
 - Air Placement (Toggle): Description unknown as of December 2025.
 
-## Content Creation Tools
+## Ferramentas de criação de conteúdo
 
-Hytale includes a variety of built-in content creation tools to help players create and edit content.
+O Hytale inclui uma variedade de ferramentas integradas de criação de conteúdo para ajudar os jogadores a criar e editar conteúdo.
 
-### Asset Editor
+### Editor de recursos
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
-### Model Editor
+### Editor de modelo
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
-### Asset Node Editor
+### Editor de nós de recursos
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
-### World Tools
+### Ferramentas do mundo
 
-These are tools that allow the user to directly edit the current world.
+As ferramentas a seguir permitem que o usuário edite o mundo atual:
 
-#### Prefab Editor
+#### Editor de prefab
 
-Allows the user to create or edit prefabs in a separate space.
+Permite que o usuário crie ou edite os prefabs em um espaço separado.
 
 ##### Configurações
 
@@ -192,52 +192,52 @@ Allows the user to create or edit prefabs in a separate space.
 - Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
 - Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
 
-#### Prefab List
+#### Lista de prefabs
 
 - Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
 - User can pick from server, assets, or worldgen prefabs.
 
-#### Spawn NPC
+#### Gerador de NPC
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
-#### Spawn Particle
+#### Gerador de partículas
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
-#### Change Player Model
+#### Alterar modelo do jogador
 
-- Allows the player to change their model with an adjustable scale.
+- Permite ao jogador alterar seu modelo com uma escala ajustável.
 
 #### Tint Chunk
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
-#### Instances
+#### Instâncias
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
-### Builder Tools
+### Ferramentas do construtor
 
-Unknown as of December 2025.
+Desconhecido até dezembro de 2025.
 
 ### Machinima
 
-Machinima is a built-in sequence editor, allowing the user to create and edit sequences of actions to be played back in game. It includes a built-in interactive keyframe editor.
+O Machinima é um editor de sequências integrado permitindo que o usuário crie e edite as sequências de ações a serem reproduzidas no jogo. Inclui um editor de keyframes interativo integrado.
 
-The speed of playback can be adjusted via commands.
+A velocidade de reprodução pode ser ajustada por meio de comandos.
 
-The user may add actors for the sequence to control.
+O usuário pode adicionar atores para que a sequência os controle.
 
-- Reference
-- Camera
-- Entity
+- Referência
+- Câmera
+- Entidade
 - Item
-- Player
+- Jogador
 
 ## Comandos
 
-Os comandos são digitados no chat do console do mundo e devem começar com uma barra `/`.
+Os comandos são digitados no bate-papo do console do mundo e devem começar com uma barra `/`.
 
-- `set <block>`: allows the user to set the blocks in a selection to the specified block.
-- `inventory clear`: allows the user to clear their inventory.
+- `set <block>`: permite que o usuário defina os blocos em uma seleção para o bloco especificado.
+- `inventory clear`: permite que o usuário limpe o inventário.
diff --git a/content/docs/pt-BR/established-information/server/interface/ui-customization.mdx b/content/docs/pt-BR/established-information/server/interface/ui-customization.mdx
index 08c55f02..889f07f0 100644
--- a/content/docs/pt-BR/established-information/server/interface/ui-customization.mdx
+++ b/content/docs/pt-BR/established-information/server/interface/ui-customization.mdx
@@ -1,28 +1,28 @@
 ---
-title: Personalização da IU
-description: Informações sobre a personalização da IU no Hytale.
+title: Personalização da interface
+description: Informações sobre a personalização da interface no Hytale.
 ---
 
 A interface do usuário pode ser personalizada por mods feitos diretamente no **lado do servidor**. Grande parte das telas da interface do usuário, mostradas aos jogadores, podem ser modificadas pelos donos de servidores através de mods.
 
-## Personalização da IU no Hytale
+## Personalização da interface no Hytale
 
-O Hytale oferece extensas capacidades de personalização da interface do usuário através de mods gerenciados pelo servidor, permitindo que os donos de servidores modifiquem muitas das páginas da IU com as quais os jogadores interagem.
+O Hytale oferece extensas capacidades de personalização da interface através de mods gerenciados pelo servidor, permitindo que os donos de servidores modifiquem muitas das páginas da interface com as quais os jogadores interagem.
 
 ### Controle de fluxo
 
-O sistema de IU do Hytale adota um padrão de fluxo de controle específico:
+O sistema de interface do Hytale adota um padrão de fluxo de controle específico:
 
-1. O servidor envia os dados da IU para o cliente
-2. O cliente renderiza a IU
-3. O usuário interage com a IU (p. ex.: pressionando um botão)
-4. O cliente envia o evento de interação para o servidor
-5. O servidor executa a lógica de retorno de chamada para o evento
+1. O servidor envia os dados da interface para o cliente;
+2. O cliente renderiza a interface;
+3. O usuário interage com a interface (p. ex.: pressionando um botão);
+4. O cliente envia o evento de interação para o servidor;
+5. O servidor executa a lógica de retorno de chamada para o evento.
 
 Essa arquitetura significa:
 
-* O cliente é responsável por renderizar a IU e enviar as interações do usuário para o servidor
-* O servidor lida com toda a lógica real por trás das interações do usuário
+* O cliente é responsável por renderizar a interface e enviar as interações do usuário para o servidor;
+* O servidor lida com toda a lógica real por trás das interações do usuário.
 
 <Callout type="warning" title="Possíveis implicações no desempenho">
   <span>
@@ -30,29 +30,29 @@ Essa arquitetura significa:
   </span>
 
   <span>
-    Additionally, since client-side modding is not supported, no modded values
-    persist on the client.
+    Além disso, uma vez que a modificação em client-side não é suportada. Por isso, nenhum valor modificado
+    fica no client.
   </span>
 </Callout>
 
-### UI Layout Assets
+### Recursos de modelo da interface
 
-Hytale's UI customization system works through the following structure:
+O sistema de personalização da interface do Hytale funciona através da seguinte estrutura:
 
-* **UI Layout**: Sent to the client as an asset
-* **UI Behavior**: Defined in Java code
-* **Custom Layouts**: Enables creation of bespoke UI layouts rather than repurposing existing ones (unlike inventory menu modifications in Minecraft)
+* **Modelo da interface**: enviado ao client como um recurso;
+* **Comportamento da interface**: definido no código Java;
+* **Modelos personalizados**: permite a criação de modelos de interface sob medida ao invés de reaproveitar os existentes (como modificações no menu do Minecraft).
 
-### UI Framework Implementations
+### Implementações do framework para a interface
 
-Hytale currently supports multiple UI implementations, with plans to consolidate on NoesisGUI:
+Atualmente, o Hytale é compatível com várias implementações de interface, com planos para consolidar no NoesisGUI:
 
 #### Implementação legado
 
-* Serves as an example of server modding capabilities
-* Uses a combination of in-game elements, UI Markup Assets, and Java mod code
-* Utilizes a legacy custom markup language
-* Will be deprecated in favor of NoesisGUI
+* Serve como um exemplo das capacidades de modificação do servidor;
+* Usa uma combinação de elementos do jogo, recursos de marcação de interface e código de mod em Java;
+* Utiliza uma linguagem de marcação personalizada legado;
+* Será descontinuado a favor do NoesisGUI.
 
 #### NoesisGUI (framework principal)
 
@@ -71,7 +71,7 @@ Hytale currently supports multiple UI implementations, with plans to consolidate
 Devido à natureza do processamento server-side da IU, há características de desempenho que devem ser consideradas, como:
 
 * **Impacto na latência**: os cliques dos botões e interações com a interface do usuário devem viajar para o servidor antes de ter efeito. Isso significa que a latência da rede afeta diretamente a capacidade de resposta da IU;
-* **No Client Persistence**: Since client-side modding is not supported, no modded values persist on the client
-* **Optimized Architecture**: Hytale's system is designed to minimize latency through efficient communication protocols and optimized server performance, ensuring smooth interactions despite server-side processing requirements
+* **Sem persistência no client**: como as modificações em client-side não são permitidas, então nenhum valor modificado permanece salvo no client;
+* **Arquitetura otimizada**: o sistema do Hytale foi projetado para minimizar a latência por meio de protocolos de comunicação eficientes e desempenho de servidor otimizado, garantindo interações fluidas, apesar dos requisitos de processamento em server-side.
 
-The architecture prioritizes security and consistency by centralizing UI logic on the server while maintaining responsive user experiences
+A arquitetura prioriza a segurança e a consistência ao centralizar a lógica da interface no servidor mantendo experiências responsivas do usuário.
diff --git a/content/docs/pt-BR/established-information/server/server-first-dev.mdx b/content/docs/pt-BR/established-information/server/server-first-dev.mdx
index c333232b..3da29694 100644
--- a/content/docs/pt-BR/established-information/server/server-first-dev.mdx
+++ b/content/docs/pt-BR/established-information/server/server-first-dev.mdx
@@ -1,29 +1,29 @@
 ---
-title: Desenvolvimento Server-First
+title: Desenvolvimento server-first
 description: Informações sobre o significado de "desenvolvimento server-first" e mais.
 ---
 
-O Hytale está sendo desenvolvido com uma abordagem de "server-first". This means that the server is considered the authoritative source of game state and logic, while the client primarily handles rendering and user input.
+O Hytale está sendo desenvolvido com uma abordagem em server-first. Isso significa que o servidor é considerado a fonte autoritativa do estado e da lógica do jogo, enquanto o client lida, principalmente, com a renderização e a entrada do usuário.
 
 ## O que significa "server-first"?
 
-Em uma arquitetura server-first, o servidor é responsável por gerenciar o mundo do jogo, aplicando as regras e processando as ações dos jogadores. The client connects to the server to receive updates about the game state and to send player inputs. This approach helps ensure consistency and fairness in multiplayer environments, as the server has control over the game logic.
+Em uma arquitetura server-first, o servidor é responsável por gerenciar o mundo do jogo, aplicando as regras e processando as ações dos jogadores. O cliente se conecta ao servidor para receber atualizações sobre o estado do jogo e para enviar os comandos do jogador. Essa abordagem ajuda a garantir a consistência e a justiça em ambientes multijogadores, já que o servidor tem o controle sobre a lógica do jogo.
 
 ## Benefícios do desenvolvimento server-first
 
-* **Consistency**: Since the server is the authoritative source, all players experience the same game state, reducing discrepancies and cheating.
-* **Escalabilidade**: Arquiteturas server-first podem ser mais facilmente dimensionadas para acomodar números grandes
+* **Consistência**: como o servidor é a fonte autoritativa, todos os jogadores vivenciam o mesmo estado de jogo, reduzindo discrepâncias e trapaças;
+* **Escalabilidade**: arquiteturas server-first podem ser mais facilmente dimensionadas para acomodar números grandes
   de jogadores, já que o servidor pode gerenciar recursos e distribuir o carregamento de forma eficaz.
-* **Security**: By centralizing game logic on the server, it becomes more difficult for players to manipulate the game state unfairly.
-* **Easier Updates**: Updates and changes can be made on the server side without requiring players to download new client versions.
-* **Only One Version**: There won't be a version selector for the Hytale Client, meaning that server owners do not need to support multiple versions and can rely on everyone being on the latest client. This will help both server owners and modders.
+* **Segurança**: ao centralizar a lógica do jogo no servidor, torna-se mais difícil para os jogadores manipularem o estado do jogo de forma injusta;
+* **Atualizações facilitadas**: as atualizações e as mudanças podem ser feitas em server-side sem exigir que os jogadores baixem novas versões do client;
+* **Versão única**: não haverá um seletor de versão para o client do Hytale, o que significa que os donos de servidores não precisam oferecer suporte a múltiplas versões e podem contar com todos os jogadores na versão mais recente. Isso ajudará tanto os donos de servidores quanto os criadores de mods.
 
-## Implications for Modding
+## Implicações para a criação de mods
 
-Modders will primarily interact with the server-side components of Hytale. This means that mods will often focus on altering game logic, rules, and behaviors that are managed by the server. Client-side modifications are not allowed (as of the information given right now).
+Os criadores de mods interagirão, principalmente, com os componentes em server-side de Hytale. Isso significa que os mods focarão em alterar a lógica, regras e comportamentos que são gerenciados pelo servidor. Os mods em client-side não são permitidos (de acordo com as informações fornecidas até o momento).
 
 De forma geral, a abordagem server-first em Hytale tem como foco criar uma experiência multijogador robusta e justa. Além disso, fornece ferramentas poderosas aos criadores de mods para personalizarem e aprimorarem o jogo.
 
 ## Conclusão
 
-O modelo de desenvolvimento server-first é um aspecto fundamental na arquitetura do Hytale, garantindo uma experiência multijogador segura e consistente. Modders should focus on server-side modifications to fully leverage the capabilities of this approach and create engaging content for players.
+O modelo de desenvolvimento server-first é um aspecto fundamental na arquitetura do Hytale, garantindo uma experiência multijogador segura e consistente. Os criadores de mods devem focar em mods em server-side para usufruírem totalmente das capacidades dessa abordagem e criar conteúdos envolventes para os jogadores.
diff --git a/content/docs/pt-BR/guides/ecs/entity-component-system.mdx b/content/docs/pt-BR/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/pt-BR/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/pt-BR/guides/ecs/example-ecs-plugin.mdx b/content/docs/pt-BR/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/pt-BR/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/pt-BR/guides/ecs/hytale-ecs-theory.mdx b/content/docs/pt-BR/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/pt-BR/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/pt-BR/guides/ecs/systems.mdx b/content/docs/pt-BR/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/pt-BR/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/pt-BR/guides/java-basics/00-introduction.mdx b/content/docs/pt-BR/guides/java-basics/00-introduction.mdx
index bd5ee7ae..c31ca3d5 100644
--- a/content/docs/pt-BR/guides/java-basics/00-introduction.mdx
+++ b/content/docs/pt-BR/guides/java-basics/00-introduction.mdx
@@ -3,7 +3,7 @@ title: 00 — Introdução ao Java
 description: Um guia para iniciantes com os fundamentos da programação Java para começar a modificar o Hytale.
 ---
 
-Bem-vindo à sua jornada em Programação Java! Este guia foi projetado para lhe apresentar ao básico do java.
+Bem-vindo(a) à sua jornada em programação Java! Este guia foi projetado para apresentar a você os fundamentos do java.
 
 ## O que é Java?
 
@@ -13,7 +13,7 @@ O Java é uma linguagem de programação poderosa e orientada a objetos, criada
 
 Este guia foi estruturado para ajudá-lo passo a passo:
 
-1. Sintaxe e noções básicas de Java;
+1. Sintaxe e fundamentos do Java;
 2. Controle de fluxo;
 3. Programação orientada a objetos.
 
@@ -23,11 +23,11 @@ Focaremos apenas nos conceitos específicos do Hytale. (A fazer)
 
 Antes de mergulharmos na programação, você vai precisar de algumas ferramentas excrescenciais, você precisa instalar:
 
-### Kit de Desenvolvimento Java (JDK)
+### Kit de desenvolvimento Java (JDK)
 
-Baixe e instale JDK 25 ou mais do [site oficial da Oracle](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) ou use uma alternativa de código aberto como a [AdoptOpenJDK](https://adoptopenjdk.net/).
+Baixe e instale o JDK 25 ou superior no [site oficial da Oracle](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html). Se preferir, use uma alternativa de código aberto, como a [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Ambientes de Desenvolvimento Integrado (IDE)
+### Ambiente de desenvolvimento integrado (IDE)
 
 Uma IDE é um aplicativo de software que oferece recursos facilitadores para programadores durante o desenvolvimento de software. Escolhas populares para Java incluem:
 
@@ -42,9 +42,9 @@ Uma IDE é um aplicativo de software que oferece recursos facilitadores para pro
 4. Pratique - Cada artigo inclui exercícios
 5. Seja paciente - Programar é uma habilidade que leva tempo para se desenvolver
 
-## A mentalidade de modding
+## A mentalidade de criação de mods
 
-Modding é uma resolução criativa de problemas. Você irá:
+A criação de mods é uma resolução criativa de problemas. Você irá:
 
 * Adicionar novos blocos, itens e criaturas para o Hytale;
 * Mudar as mecânicas de jogo para criar experiências únicas;
diff --git a/content/docs/pt-BR/guides/java-basics/06-methods-functions.mdx b/content/docs/pt-BR/guides/java-basics/06-methods-functions.mdx
index 9f0aa265..e0821a99 100644
--- a/content/docs/pt-BR/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/pt-BR/guides/java-basics/06-methods-functions.mdx
@@ -377,6 +377,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Tenha pelo menos um número
    * Retorna *true* se for válido, e *false* se não for
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Erros comuns
 
 ```java
diff --git a/content/docs/pt-BR/guides/java-basics/08-access-modifiers.mdx b/content/docs/pt-BR/guides/java-basics/08-access-modifiers.mdx
index 8e329a4c..015eb51d 100644
--- a/content/docs/pt-BR/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/pt-BR/guides/java-basics/08-access-modifiers.mdx
@@ -1,11 +1,11 @@
 ---
-title: 08 - Encapsulation and Access Modifiers
-description: Learn how to protect and control access to your class data.
+title: 08 — Encapsulamento e modificadores de acesso
+description: Aprenda a proteger e controlar o acesso aos dados para as suas classes.
 ---
 
-Encapsulation is about hiding the internal details of a class and controlling how its data is accessed and modified. This prevents bugs and makes your code more maintainable.
+O encapsulamento consiste em ocultar os detalhes internos de uma classe e determinar como os seus dados podem ser acessados ou modificados. Isso evita que erros aconteçam e o seu código se torna mais simples de manter e atualizar.
 
-## The Problem Without Encapsulation
+## O problema sem o encapsulamento
 
 ```java
 public class Player {
@@ -28,11 +28,11 @@ public class Main {
 }
 ```
 
-Without protection, anyone can set invalid values!
+Sem proteção, qualquer um pode definir valores inválidos!
 
-## Access Modifiers
+## Modificadores de acesso
 
-Java has keywords that control who can access your class members:
+O Java tem palavras-chave que controlam quem pode acessar os membros da sua classe:
 
 | Modificador | Classe | Pacote | Subclasse | Mundo |
 | ----------- | ------ | ------ | --------- | ----- |
@@ -46,7 +46,7 @@ Java has keywords that control who can access your class members:
 * `public` — Qualquer pessoa pode acessar
 * `private` — Apenas essa classe pode acessar
 
-## Making Properties Private
+## Tornando propriedades privadas
 
 ```java
 public class Player {
@@ -62,7 +62,7 @@ public class Player {
 }
 ```
 
-Now you can't access properties directly:
+Não é mais possível acessar as propriedades diretamente:
 
 ```java
 Player player = new Player("Alice", 100);
@@ -124,11 +124,11 @@ System.out.println(player.getHealth());  // 0
 ```
 
 <Callout type="info" title="Nomeação Getter e Setter">
-  Follow Java naming conventions:
+  Siga as convenções de nomenclatura do Java:
 
   * **Getter**: `get` + nome da propriedade (capitalizado);
   * **Setter**: `set` + nome da propriedade (capitalizado);
-  * **Boolean**: `is` + nome da propriedade (capitalizado)
+  * **Boolean**: `is` + nome da propriedade (capitalizado).
 
   ```java
   private int health;
@@ -145,7 +145,7 @@ System.out.println(player.getHealth());  // 0
   ```
 </Callout>
 
-## Benefits of Encapsulation
+## Vantagens do encapsulamento
 
 ### 1. Validação
 
@@ -170,9 +170,9 @@ public class Item {
 }
 ```
 
-### 2. Read-Only Properties
+### 2. Propriedades apenas de leitura
 
-Sometimes you don't want a setter:
+Às vezes, você não quer um `setter`:
 
 ```java
 public class Monster {
@@ -244,23 +244,23 @@ public class Tool {
     
     public void use() {
         if (broken) {
-            System.out.println(name + " is broken!");
+            System.out.println(name + " está quebrado(a)!");
             return;
         }
         
         durability--;
-        System.out.println(name + " used. Durability: " + durability);
+        System.out.println(name + " usado(a). Durabilidade: " + durability);
         
         if (durability <= 0) {
             broken = true;
-            System.out.println(name + " broke!");
+            System.out.println(name + " quebrou!");
         }
     }
     
     public void repair() {
         durability = maxDurability;
         broken = false;
-        System.out.println(name + " repaired!");
+        System.out.println(name + " reparado(a)!");
     }
     
     // Getters
@@ -285,7 +285,6 @@ public class Tool {
 ### Exemplo de conta bancária
 
 ```java
-public class PlayerWallet {
     private int gold;
     private int silver;
     
@@ -297,18 +296,18 @@ public class PlayerWallet {
     public void addGold(int amount) {
         if (amount > 0) {
             gold += amount;
-            System.out.println("Added " + amount + " gold");
+            System.out.println(amount + "x ouro(s) adicionado(s)");
         }
     }
     
     public boolean spendGold(int amount) {
         if (amount > gold) {
-            System.out.println("Not enough gold!");
+            System.out.println("Ouro insuficiente!");
             return false;
         }
         
         gold -= amount;
-        System.out.println("Spent " + amount + " gold");
+        System.out.println(amount + "x ouro(s) usado(s)");
         return true;
     }
     
@@ -317,7 +316,7 @@ public class PlayerWallet {
     }
     
     public int getTotalValue() {
-        // 1 gold = 100 silver
+        // 1 ouro = 100 pratas
         return gold * 100 + silver;
     }
 }
diff --git a/content/docs/pt-BR/guides/java-basics/09-string.mdx b/content/docs/pt-BR/guides/java-basics/09-string.mdx
index 49b5f278..1a66122c 100644
--- a/content/docs/pt-BR/guides/java-basics/09-string.mdx
+++ b/content/docs/pt-BR/guides/java-basics/09-string.mdx
@@ -16,7 +16,7 @@ String empty = "";
 ```
 
 <Callout type="warning" title="Strings são imutáveis">
-  Uma vez criada, uma string **não pode ser alterada**. Methods that seem to modify a string actually create a new one!
+  Uma vez criada, uma string **não pode ser alterada**. Métodos que parecem modificar uma string e realmente criam uma nova!
 
   ```java
   String text = "Olá";
@@ -177,7 +177,7 @@ String result = "Olá".concat(" Mundo");  // "Olá Mundo"
 
 ### Construindo strings longas
 
-For many concatenations, use `StringBuilder`:
+Para muitas concatenações, use o `StringBuilder`:
 
 ```java
 StringBuilder builder = new StringBuilder();
@@ -197,26 +197,26 @@ System.out.println(result);
   A concatenação regular cria muitas strings temporárias:
 
   ```java
-  // Inefficient - Creates many temporary strings
+  // Ineficiente — Cria muitas strings temporárias
   String result = "";
   for (int i = 0; i < 1000; i++) {
-      result = result + i;  // Creates 1000 temporary strings!
+      result = result + i;  // Cria 1000 strings temporárias!
   }
 
-  // Efficient - StringBuilder is mutable
+  // Eficiente — StringBuilder é mutável
   StringBuilder sb = new StringBuilder();
   for (int i = 0; i < 1000; i++) {
-      sb.append(i);  // Modifies one object
+      sb.append(i);  // Modifica um objeto
   }
   String result = sb.toString();
   ```
 
-  Use `StringBuilder` when building strings in loops!
+  Use `StringBuilder` ao montar strings em repetições!
 </Callout>
 
 ## Exemplos práticos
 
-### Parse Player Command
+### Analisar comando do jogador
 
 ```java
 public class CommandParser {
@@ -253,17 +253,17 @@ public class PlayerFormatter {
         }
         
         formatted.append(name);
-        formatted.append(" (Lv. ").append(level).append(")");
+        formatted.append(" (Nv. ").append(level).append(")");
         
         return formatted.toString();
     }
     
     public static void main(String[] args) {
         String display1 = formatName("Alice", 10, "VIP");
-        System.out.println(display1);  // "[VIP] Alice (Lv. 10)"
+        System.out.println(display1);  // "[VIP] Alice (Nv. 10)"
         
         String display2 = formatName("Bob", 5, null);
-        System.out.println(display2);  // "Bob (Lv. 5)"
+        System.out.println(display2);  // "Bob (Nv. 5)"
     }
 }
 ```
@@ -273,7 +273,7 @@ public class PlayerFormatter {
 ```java
 public class UsernameValidator {
     public static boolean isValid(String username) {
-        // Rules: 3-16 characters, letters and numbers only
+        // Regras: 3-16 caracteres, somente letras e números
         
         if (username == null || username.isEmpty()) {
             return false;
@@ -296,15 +296,15 @@ public class UsernameValidator {
     }
     
     public static void main(String[] args) {
-        System.out.println(isValid("Steve"));      // true
-        System.out.println(isValid("Player_123")); // false (has underscore)
-        System.out.println(isValid("ab"));         // false (too short)
-        System.out.println(isValid(""));           // false (empty)
+        System.out.println(isValid("Steve"));      // correto
+        System.out.println(isValid("Player_123")); // errado (tem sublinhado)
+        System.out.println(isValid("ab"));         // errado (muito curto)
+        System.out.println(isValid(""));           // errado (vazio)
     }
 }
 ```
 
-### Item Description Builder
+### Construtor de descrições de itens
 
 ```java
 public class ItemDescription {
@@ -312,27 +312,27 @@ public class ItemDescription {
                                          int damage, int durability) {
         StringBuilder desc = new StringBuilder();
         
-        // Title with rarity color code
+        // Título com código de cor de raridade
         desc.append(getRarityColor(rarity));
         desc.append(name);
         desc.append("\n");
         
-        // Stats
-        desc.append("Damage: ").append(damage).append("\n");
-        desc.append("Durability: ").append(durability).append("/");
+        // Status
+        desc.append("Dano: ").append(damage).append("\n");
+        desc.append("Durabilidade: ").append(durability).append("/");
         desc.append(durability).append("\n");
-        desc.append("Rarity: ").append(rarity);
+        desc.append("Raridade: ").append(rarity);
         
         return desc.toString();
     }
     
     private static String getRarityColor(String rarity) {
         switch (rarity.toLowerCase()) {
-            case "legendary": return "§6";  // Gold
-            case "epic": return "§5";       // Purple
-            case "rare": return "§9";       // Blue
-            case "common": return "§f";     // White
-            default: return "§7";           // Gray
+            case "legendary": return "§6";  // Dourado
+            case "epic": return "§5";       // Roxo
+            case "rare": return "§9";       // Azul
+            case "common": return "§f";     // Branco
+            default: return "§7";           // Cinza
         }
     }
     
@@ -343,7 +343,7 @@ public class ItemDescription {
 }
 ```
 
-### Chat Message Filter
+### Filtro de mensagens do bate-papo
 
 ```java
 public class ChatFilter {
@@ -370,58 +370,58 @@ public class ChatFilter {
 }
 ```
 
-## String Formatting
+## Formatação de string
 
-### Using String.format()
+### Usando `String.format()`
 
 ```java
 String name = "Alice";
 int level = 10;
 double health = 85.5;
 
-String formatted = String.format("%s is level %d with %.1f%% health", 
+String formatted = String.format("%s está no nível %d com %.1f%% de vida", 
                                  name, level, health);
 System.out.println(formatted);
-// "Alice is level 10 with 85.5% health"
+// "Alice está no nível 10 com 85.5% de vida"
 ```
 
-<Callout type="info" title="Format Specifiers">
-  Common format codes:
+<Callout type="info" title="Especificadores de formatação">
+  Códigos de formatação comuns:
 
   - `%s` — String
-  - `%d` - Integer
-  - `%f` - Floating point
-  - `%.2f` - Float with 2 decimal places
-  - `%n` - New line (platform independent)
+  - `%d` — Integer
+  - `%f` — Ponto flutuante (decimal)
+  - `%.2f` — Float com 2 casas decimais
+  - `%n` — Nova linha (independente da plataforma)
 
   ```java
-  String.format("Name: %s", "Steve");          // "Name: Steve"
-  String.format("Level: %d", 10);              // "Level: 10"
-  String.format("Health: %.1f", 85.5);         // "Health: 85.5"
-  String.format("Position: (%d, %d, %d)", 
-                10, 64, -5);                    // "Position: (10, 64, -5)"
+  String.format("Nome: %s", "Steve");          // "Nome: Steve"
+  String.format("Nível: %d", 10);              // "Nível: 10"
+  String.format("Vida: %.1f", 85.5);         // "Vida: 85.5"
+  String.format("Posição: (%d, %d, %d)", 
+                10, 64, -5);                    // "Posição: (10, 64, -5)"
   ```
 </Callout>
 
-## Common String Operations
+## Operações comuns com as strings
 
-### Check if String is Empty
+### Verificar se a string está vazia
 
 ```java
 String text = "";
 
-// Check for empty or null
+// Verificar se está vazio ou nulo
 if (text == null || text.isEmpty()) {
-    System.out.println("Empty!");
+    System.out.println("Vazio!");
 }
 
-// Check for empty, null, or whitespace only
+// Verificar se há apenas valores vazios, nulos ou espaços em branco
 if (text == null || text.trim().isEmpty()) {
-    System.out.println("Empty or whitespace!");
+    System.out.println("Vazio ou com espaço em branco!");
 }
 ```
 
-### Count Occurrences
+### Contagem de ocorrências
 
 ```java
 public static int countOccurrences(String text, String target) {
@@ -441,7 +441,7 @@ int count = countOccurrences("hello hello world", "hello");
 System.out.println(count);  // 2
 ```
 
-### Reverse a String
+### Reverter uma string
 
 ```java
 public static String reverse(String text) {
@@ -468,7 +468,7 @@ System.out.println(isPalindrome("racecar"));     // true
 System.out.println(isPalindrome("hello"));       // false
 ```
 
-## Practice Exercises
+## Exercícios práticos
 
 1. **Username Checker**: Write a method that checks if a username:
    - Is between 3 and 16 characters
diff --git a/content/docs/pt-BR/guides/plugin/block-components.mdx b/content/docs/pt-BR/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..bac16c9e
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Componentes do bloco
+description: Aprenda a usar os componentes do bloco.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Visão geral
+
+Neste guia, você aprenderá a usar os componentes do bloco para criar um bloco-tique-taque.
+
+<Callout>
+  Para uma referência mais completa, recomenda-se rever o `FarmingSystems.Ticking`, uma vez que grande parte da lógica subjacente é baseada em sua implementação.
+</Callout>
+
+## Etapas
+
+### 1. `ExampleBlock` — Contém o comportamento do bloco
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. `ExampleSystem` — Manipula o tique-taque (_ticking_)
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Obtenha o componente do bloco**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Converter as coordenadas do chunk local para as coordenadas do mundo**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Execute a lógica do bloco**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Mantenha o bloco em ticking no próximo tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. `ExamplePlugin` — Registra os componentes e sistemas
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configurar dentro do jogo
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+Com essa lógica, o bloco agora posicionará continuamente um Bloco de Gelo na coordenada X + 1, em relação à sua posição atual, a cada tick.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/pt-BR/guides/plugin/browsing-serverjar.mdx b/content/docs/pt-BR/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/pt-BR/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/pt-BR/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/pt-BR/guides/plugin/build-and-test.mdx b/content/docs/pt-BR/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/pt-BR/guides/plugin/chat-formatting.mdx b/content/docs/pt-BR/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/pt-BR/guides/plugin/chat-formatting.mdx
+++ b/content/docs/pt-BR/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/pt-BR/guides/plugin/client-inputs-reference.mdx b/content/docs/pt-BR/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/pt-BR/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/pt-BR/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/pt-BR/guides/plugin/creating-block.mdx b/content/docs/pt-BR/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/pt-BR/guides/plugin/creating-block.mdx
+++ b/content/docs/pt-BR/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/pt-BR/guides/plugin/creating-commands.mdx b/content/docs/pt-BR/guides/plugin/creating-commands.mdx
index 4066a565..b2b9fe16 100644
--- a/content/docs/pt-BR/guides/plugin/creating-commands.mdx
+++ b/content/docs/pt-BR/guides/plugin/creating-commands.mdx
@@ -1,24 +1,76 @@
 ---
-title: Creating Commands
-description: Learn how to create custom commands for your Hytale mod.
+title: Criando comandos
+description: Aprenda a criar comandos personalizados para o seu mod de Hytale.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### A classe `AbstractPlayerCommand`
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -28,28 +80,342 @@ public class ExampleCommand extends AbstractPlayerCommand {
 
   @Override
   protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
-    Player player = store.getComponent(ref, Player.getComponentType()); // also a component
+    Player player = store.getComponent(ref, Player.getComponentType()); // Também um componente
     UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
     TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
-    player.sendMessage(Message.raw("Player#getUuid() : " + player.getUuid())); // returns UUID from UUIDComponent
+    player.sendMessage(Message.raw("Player#getUuid() : " + player.getUuid())); // Retorna o UUID do UUIDComponent
     player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
-    player.sendMessage(Message.raw("equal : " + player.getUuid().equals(component.getUuid()))); // they're both the same
+    player.sendMessage(Message.raw("equal : " + player.getUuid().equals(component.getUuid()))); // Ambos são os mesmos
     player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
   }
 
 }
 ```
 
-## Registering the Command
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adicionando argumentos
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Argumentos opcionais
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
 
-For any command
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
+## Registrando o comando
+
+Para qualquer comando
 
 ```java
 public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/pt-BR/guides/plugin/creating-configuration-file.mdx b/content/docs/pt-BR/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/pt-BR/guides/plugin/creating-events.mdx b/content/docs/pt-BR/guides/plugin/creating-events.mdx
index d14a4450..c5d6df8a 100644
--- a/content/docs/pt-BR/guides/plugin/creating-events.mdx
+++ b/content/docs/pt-BR/guides/plugin/creating-events.mdx
@@ -1,18 +1,18 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Criando eventos
+description: Aprenda a criar eventos personalizados para o seu mod de Hytale.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
-## Event Class
+## Classe de evento
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+Você pode importar uma classe de evento e criar uma função com o evento como argumento. [Clique aqui](../../server/events) para ver todos os eventos disponíveis.
 
-Example plugin when a player is ready (joins a server):
+Exemplo de plugin para quando um jogador estiver pronto (entrar num servidor):
 
 ```java
 
@@ -20,15 +20,15 @@ public class ExampleEvent {
 
     public static void onPlayerReady(PlayerReadyEvent event) {
         Player player = event.getPlayer();
-        player.sendMessage(Message.raw("Welcome " + player.getDisplayName()));
+        player.sendMessage(Message.raw("Bem-vindo(a) " + player.getDisplayName()));
     }
 
 }
 ```
 
-## Registering the Event
+## Registrando o evento
 
-You need to register all events you make in the Main plugin class, usually in the `setup` function.
+Todos os eventos devem ser registrados na classe principal do plugin, geralmente localizado na função `setup`.
 
 ```java
 public class MyPlugin extends JavaPlugin {
@@ -40,10 +40,10 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
-An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+Veja abaixo um exemplo que cancelará a criação de uma receita caso ela use fibra como ingrediente:
 
 ```java
 class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent.Pre> {
@@ -75,9 +75,9 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
-You will need to register the system in your plugin:
+Você precisará registrar o sistema no seu plugin:
 
 ```java
 public class MyPlugin extends JavaPlugin {
diff --git a/content/docs/pt-BR/guides/plugin/customizing-camera-controls.mdx b/content/docs/pt-BR/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/pt-BR/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/pt-BR/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/pt-BR/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/pt-BR/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/pt-BR/guides/plugin/instances.mdx b/content/docs/pt-BR/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/pt-BR/guides/plugin/inventory-management.mdx b/content/docs/pt-BR/guides/plugin/inventory-management.mdx
index feb25b06..ecc82e31 100644
--- a/content/docs/pt-BR/guides/plugin/inventory-management.mdx
+++ b/content/docs/pt-BR/guides/plugin/inventory-management.mdx
@@ -1,9 +1,9 @@
 ---
-title: Inventory Management
+title: Gerenciamento de inventário
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/pt-BR/guides/plugin/item-interaction.mdx b/content/docs/pt-BR/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..1516e778
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusão
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/pt-BR/guides/plugin/listening-to-packets.mdx b/content/docs/pt-BR/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..f865b556
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+Isso é uma superclasse de `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/pt-BR/guides/plugin/logging.mdx b/content/docs/pt-BR/guides/plugin/logging.mdx
new file mode 100644
index 00000000..98f8504d
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Registrando
+description: Aprenda a registrar mensagens no servidor usando o sistema de registro de logs do Hytale.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+Uma forma de registrar mensagens é usando a própria classe de registro do Hytale, a `HytaleLogger` que estende a classe `com.google.common.flogger.AbstractLogger`. Os registros aparecerão no mesmo arquivo de registro utilizado pelo servidor do Hytale, na pasta de registros do servidor em `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+O registrador permite a atribuição de um nome ao realizar a chamada `HytaleLogger.get("<logger name>")`. O nome do registrador será adicionado antes da mensagem de registro, facilitando sua identificação dentro do arquivo de registro.
+
+Existe o método `.forEnclosingClass()` que pode ser utilizado para obter automaticamente o registrador do arquivo em uso, sem a necessidade de alterá-lo manualmente a cada nova implementação.
+
+Um exemplo de utilização da classe de registro do Hytale para registrar mensagens, através de um atributo estático na classe principal do plugin:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("meu plugin de exemplo carregou");
+  }
+}
+```
+
+O registrador poderá ser usado em qualquer local, como no exemplo abaixo:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("olá mundo");
+```
+
+## Níveis de registro
+
+Todas as mensagens de registro têm um nível associado. O nível pode ser usado para categorizar as mensagens e a configurar como elas são registradas. Utilizando as configurações padrões, apenas as mensagens de `Info`, `Warn` e `Severe` são mostradas.
+
+```java
+    LOGGER.atInfo().log("Fornece informações de alto nível sobre o comportamento normal do sistema.");
+    LOGGER.atWarning().log("Sinaliza um problema em potencial ou uma situação que pode levar a um erro.");
+    LOGGER.atSevere().log("Um erro grave que impedirá o funcionamento conforme o esperado.");
+```
+
+## Argumentos de modelo
+
+O HytaleLogger usa argumentos no estilo `printf` e deve oferecer suporte à maioria dos recursos e especificadores utilizados na formatação de strings convencionais.
+
+```java
+final String name = "Mundo";
+LOGGER.atInfo().log("Olá %s", name);
+// mostra: Olá Mundo
+```
+
+Segue um breve resumo dos especificadores mais comuns:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceções e causas
+
+Caso a mensagem de `log` tenha uma exceção associada ou exija a inclusão de um stack trace, é possível realizá-lo definindo a causa (`cause`).
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Erro!");
+    }
+```
diff --git a/content/docs/pt-BR/guides/plugin/permission-management.mdx b/content/docs/pt-BR/guides/plugin/permission-management.mdx
index 70aef22c..92158121 100644
--- a/content/docs/pt-BR/guides/plugin/permission-management.mdx
+++ b/content/docs/pt-BR/guides/plugin/permission-management.mdx
@@ -1,6 +1,6 @@
 ---
-title: Permission Management
-description: Learn how to manage permission nodes and groups in your Hytale plugin.
+title: Gerenciamento de permissão
+description: Aprenda a gerenciar nós de permissão e grupos no seu plugin para o Hytale.
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
diff --git a/content/docs/pt-BR/guides/plugin/player-death-event.mdx b/content/docs/pt-BR/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/pt-BR/guides/plugin/player-input-guide.mdx b/content/docs/pt-BR/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/pt-BR/guides/plugin/player-input-guide.mdx
+++ b/content/docs/pt-BR/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/pt-BR/guides/plugin/player-stats.mdx b/content/docs/pt-BR/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/pt-BR/guides/plugin/setting-up-env.mdx b/content/docs/pt-BR/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/pt-BR/guides/plugin/setting-up-env.mdx
+++ b/content/docs/pt-BR/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/pt-BR/guides/plugin/spawning-entities.mdx b/content/docs/pt-BR/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/pt-BR/guides/plugin/spawning-entities.mdx
+++ b/content/docs/pt-BR/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/pt-BR/guides/plugin/spawning-npcs.mdx b/content/docs/pt-BR/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/pt-BR/guides/plugin/store-persistant-data.mdx b/content/docs/pt-BR/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/pt-BR/guides/plugin/teleporting-players.mdx b/content/docs/pt-BR/guides/plugin/teleporting-players.mdx
index bef0d9b7..976f86c2 100644
--- a/content/docs/pt-BR/guides/plugin/teleporting-players.mdx
+++ b/content/docs/pt-BR/guides/plugin/teleporting-players.mdx
@@ -1,6 +1,6 @@
 ---
-title: Teleporting the player
-description: Learn how to teleport the player.
+title: Teletransportando o jogador
+description: Aprenda a teletransportar o jogador.
 ---
 
 To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/pt-BR/guides/plugin/text-hologram.mdx b/content/docs/pt-BR/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..7c0c2340
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Visão geral
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/pt-BR/guides/plugin/ui.mdx b/content/docs/pt-BR/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/pt-BR/guides/plugin/world-gen.mdx b/content/docs/pt-BR/guides/plugin/world-gen.mdx
index 37cdddac..a5952976 100644
--- a/content/docs/pt-BR/guides/plugin/world-gen.mdx
+++ b/content/docs/pt-BR/guides/plugin/world-gen.mdx
@@ -1,66 +1,66 @@
 ---
-title: World Generation System
-description: Learn how to create custom world generation features for your Hytale mod.
+title: Sistema de geração de mundo
+description: Aprenda a criar recursos personalizados de geração de mundo para o seu mod de Hytale.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
-# Overview
+# Visão geral
 
-This section covers Hytale's procedural world generation systems that creates environments, biomes, and structures dynamically as players explore the world.
+Esta seção aborda os sistemas de geração procedural de mundo de Hytale que criam ambientes, biomas e estruturas dinamicamente à medida que os jogadores exploram o mundo.
 
-Hytale’s world generation is organized into three interconnected systems:
+A geração de mundo de Hytale é organizada em três sistemas interconectados:
 
-- **Zones** - Large-scale regions that define overall world structure
-- **Biomes** - Terrain characteristics and environmental properties within zones
-- **Caves** - Underground structures and networks generated within zones
+- **Zonas**: regiões em grande escala que definem estruturas em todo o mundo;
+- **Biomas**: características do terreno e propriedades ambientais dentro das zonas;
+- **Cavernas**: estruturas e redes subterrâneas dentro das zonas.
 
-These systems work together to create a rich, varied world with smooth transitions and coherent regional themes.
+Esses sistemas trabalham juntos para criar um mundo rico e variado, com transições suaves e temas regionais coerentes.
 
-## Getting Started
+## Primeiros passos
 
-1. Zone System - Large regions
-2. Biome System - Terrain and environment within zones
-3. Cave System - Underground structures and networks within zones
+1. Sistema de zona — Grandes regiões;
+2. Sistema de bioma — Terreno e ambiente dentro das zonas;
+3. Sistema de caverna — Estruturas e redes subterrâneas dentro das zonas;
 
-## Implementation Details
+## Detalhes de implementação
 
-### Zone Lookup and Generation
+### Busca e geração de zona
 
 ```java
 
-// Get zone at position
-ZonePatternGenerator zoneGen = /* world generator */;
+// Obter zona na posição
+ZonePatternGenerator zoneGen = /* gerador de mundo */;
 ZoneGeneratorResult zoneResult = zoneGen.generate(seed, x, z);
 Zone zone = zoneResult.getZone();
 
-// Get biome within zone
+// Obter bioma dentro da zona
 BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
 Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
-// Check for caves in zone
+// Verificação para as cavernas na zona
 CaveGenerator caveGen = zone.caveGenerator();
 if (caveGen != null) {
     CaveType[] caveTypes = caveGen.getCaveTypes();
-    // Generate caves as needed
+    // Gerar cavernas conforme necessário
 }
 ```
 
-### Creating a Custom Zone
+### Criando uma zona personalizada
 
 ```java
-// Configure zone discovery
+// Configurar descobrimento de zona
 ZoneDiscoveryConfig discovery = new ZoneDiscoveryConfig(
-    true,                           // Show notification
-    "Custom Zone",                  // Display name
-    "zone.forest.discover",         // Sound event
-    "icons/forest.png",             // Icon
-    true,                           // Major zone
-    5.0f, 2.0f, 1.5f                // Duration, fade in, fade out
+    true,                           // Mostrar notificação
+    "Zona personalizada",                  // Nome de exibição
+    "zone.forest.discover",         // Evento sonoro
+    "icons/forest.png",             // Ícone
+    true,                           // Zona principal
+    5.0f, 2.0f, 1.5f                // Duração, Aparecimento, Desaparecimento
 );
 
-// Create biome pattern
+// Criar bioma padrão
 IPointGenerator biomePoints;
 IWeightedMap<TileBiome> tileBiomes;
 CustomBiome[] customBiomes;
@@ -71,26 +71,26 @@ BiomePatternGenerator biomeGen = new BiomePatternGenerator(
     customBiomes
 );
 
-// Create cave configuration
-CaveType[] caveTypes; // cave definitions
+// Criar configuração de caverna
+CaveType[] caveTypes; // Definições de caverna
 CaveGenerator caveGen = new CaveGenerator(caveTypes);
 
-// Assemble the zone
+// Construir zona
 Zone customZone = new Zone(
-    100,                    // Unique ID
-    "new_custom_zone",      // Internal name
-    discovery,              // Discovery config
-    caveGen,                // Cave generator
-    biomeGen,               // Biome pattern
-    uniquePrefabs           // Unique structures
+    100,                    // ID único
+    "new_custom_zone",      // Nome interno
+    discovery,              // Config. de descobrimento
+    caveGen,                // Gerador de caverna
+    biomeGen,               // Bioma padrão
+    uniquePrefabs           // Estruturas únicas
 );
 ```
 
-## System Integration
+## Integração do sistema
 
-### Zone & Biome Integration
+### Integração de zona e bioma
 
-Each zone defines its own biome pattern:
+Cada zona define seu próprio padrão de bioma:
 
 ```java
 Zone zone = zoneGen.generate(seed, x, z).getZone();
@@ -98,46 +98,46 @@ BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
 Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 ```
 
-### Zone & Cave Integration
+### Integração de zona e caverna
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
 CaveGenerator caveGen = zone.caveGenerator();
 if (caveGen != null) {
-    // This zone has caves
+    // Esta zona tem cavernas
     CaveType[] types = caveGen.getCaveTypes();
 }
 ```
 
-### Biome & Cave Integration
+### Integração de bioma e caverna
 
-Caves use biome masks for placement control:
+As cavernas usam máscaras do bioma para controle de posicionamento:
 
 ```java
-// Cave type with biome restrictions
+// Tipo de caverna com restrições de bioma
 Int2FlagsCondition biomeMask = caveType.getBiomeMask();
 int biomeId = biome.getId();
 int flags = biomeMask.eval(biomeId);
 
-// Check if cave can generate in this biome
+// Verifica se a caverna pode ser gerada neste bioma
 if (CaveBiomeMaskFlags.canGenerate(flags)) {
     // Generate cave
 }
 ```
 
-### Border Transitions
+### Transições de borda
 
-All systems respect zone boundaries:
+Todos os sistemas respeitam os limites da zona:
 
 ```java
 ZoneGeneratorResult result = zoneGen.generate(seed, x, z);
 double borderDistance = result.getBorderDistance();
 
-// Fade custom biomes near borders
+// Suaviza os biomas personalizados perto das bordas
 if (borderDistance < customBiome.getFadeContainer().getMaskFadeSum()) {
     double factor = customBiome.getFadeContainer().getMaskFactor(result);
-    // Apply fading
+    // Aplica a suavização
 }
 ```
diff --git a/content/docs/pt-BR/guides/prefabs.mdx b/content/docs/pt-BR/guides/prefabs.mdx
index c258f63b..f11a04da 100644
--- a/content/docs/pt-BR/guides/prefabs.mdx
+++ b/content/docs/pt-BR/guides/prefabs.mdx
@@ -4,10 +4,10 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
-# Introduction
+# Introdução
 
 Prefabs are Hytale's way of creating reusable structures.
 
@@ -21,7 +21,7 @@ There are a few fundamental concepts to understand about prefabs:
 Be sure to check the Known Issues section at the end of this guide if you encounter any problems.
 
 1. `/editprefab new <world name>` to create a new prefab editing world: `/editprefab new my_prefab_world`
-   - Note that `my_prefab` is the name of the _world_, not the prefab itself. Worlds can contain multiple prefabs.
+   - Note que `my_prefab` é o nome do _mundo_, não do prefab em si. Worlds can contain multiple prefabs.
 2. Build whatever you want in the prefab editing world.
 3. Use the selection brush to select the area you want to save as a prefab.
 4. `/prefab save` to save the structure as a prefab.
@@ -59,9 +59,9 @@ The `/editprefab` command is used to create or edit the physical structure in th
 Subcommands:
 
 - `exit`
-  - Exits the current prefab editing world.
+  - Encerra a edição do mundo do prefab atual.
 - `load`
-  - Creates a new prefab editing world to paste an existing prefab into.
+  - Cria um novo mundo de edição de prefab para colar um prefab existente.
 - `new`
   - Creates a new prefab editing world to create a new prefab from scratch.
 - `select`
diff --git a/content/docs/pt-BR/official-documentation/npc-doc.mdx b/content/docs/pt-BR/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..200ecffc
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: Documentação para NPCs
+description: Documentação oficial para a criação e configuração de NPCs.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Nome                                                                                 | Tipo                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/pt-BR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/pt-BR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/pt-BR/publishing/builtbybit.mdx b/content/docs/pt-BR/publishing/builtbybit.mdx
new file mode 100644
index 00000000..72ad65d0
--- /dev/null
+++ b/content/docs/pt-BR/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Guia completo para publicar e vender as suas criações de Hytale na BuiltByBit.
+---
+
+# Por que a BuiltByBit?
+
+A BuiltByBit é o maior mercado de terceiros para Minecraft, Roblox e Hytale. Diferente de outras plataformas, a BuiltByBit é focada em conteúdo premium, permitindo que os criadores monetizem seu trabalho (embora recursos gratuitos também sejam bem-vindos)!
+
+Apenas alguns dias após o lançamento do acesso antecipado do Hytale, os criadores na BuiltByBit já ganharam milhares de dólares vendendo suas criações para o jogo.
+
+Principais vantagens:
+
+- Monetize seu trabalho – Defina seus próprios preços para os conteúdos premium, sem limite máximo;
+- Aprovação rápida – Tempos de revisão recordes da indústria, com média de apenas 4 horas;
+- Mais categorias – A mais ampla variedade de tipos de conteúdo entre todas as plataformas de Hytale;
+- Mercado consolidado – Entre nesse ecossistema comprovado com centenas de milhares de compradores ativos.
+
+# Categorias disponíveis
+
+A BuiltByBit é compatível com as seguintes categorias:
+Plugins – Plugins e mods em server-side;
+Ativos de dados – Pacotes de dados personalizados, tabelas de itens e conteúdos baseados em dados;
+Configurações de servidor – Configurações completas e estruturas prontas de servidores;
+Construções – Prefabs, estruturas e construções de mundo;
+Gráficos – Elementos de interface , ícones e recursos visuais;
+Texturas – Pacotes de textura e reskins;
+Modelos – Modelos 3D personalizados e animações;
+Áudio – Efeitos sonoros e músicas;
+Outros – Outras coisas que não estejam nas categorias acima.
+
+# Pré-requisitos
+
+Antes de começar, certifique-se de ter:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+Também recomendamos:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Etapas do processo de publicação
+
+## 1. Crie a sua conta
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Adicione seus recursos
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete a sua listagem
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Envie para aprovação
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. Tudo pronto!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Preços e taxas
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Obtendo ajuda
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/pt-BR/publishing/curseforge.mdx b/content/docs/pt-BR/publishing/curseforge.mdx
index d97327d5..e5eaf618 100644
--- a/content/docs/pt-BR/publishing/curseforge.mdx
+++ b/content/docs/pt-BR/publishing/curseforge.mdx
@@ -1,6 +1,6 @@
 ---
 title: CurseForge
-description: Learn how to publish your mod to CurseForge
+description: Aprenda a publicar o seu mod no CurseForge
 ---
 
 CurseForge is a mod hosting platform, allowing you to share your Hytale mods and creations with players via our website and app.
diff --git a/content/docs/pt-BR/publishing/index.mdx b/content/docs/pt-BR/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/pt-BR/publishing/index.mdx
+++ b/content/docs/pt-BR/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/pt-BR/quick-start.mdx b/content/docs/pt-BR/quick-start.mdx
index 3722d853..cc95438a 100644
--- a/content/docs/pt-BR/quick-start.mdx
+++ b/content/docs/pt-BR/quick-start.mdx
@@ -3,9 +3,9 @@ title: Primeiros passos
 description: Configure um projeto padrão de Hytale.
 ---
 
-Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+Bem-vindo(a) à documentação de criação de mods para o Hytale Esta seção contém o guia completo para o desenvolvimento dos seus próprios mods para o Hytale.
 
-* [Java Basics](./guides/java-basics/00-introduction)
-* [Setting up your dev environment](./guides/plugin/setting-up-env)
-* [Entity Component System (ECS)](./guides/ecs)
-* [Publishing your mod](./guides/publishing)
+* [Fundamentos do Java](./guides/java-basics/00-introduction)
+* [Configurando seu ambiente de desenvolvimento](./guides/plugin/setting-up-env)
+* [Sistema de componentes de entidade (ECS)](./guides/ecs)
+* [Publicando seu mod](./guides/publishing)
diff --git a/content/docs/pt-BR/server/entities.mdx b/content/docs/pt-BR/server/entities.mdx
index 872f3fa4..5671a0dc 100644
--- a/content/docs/pt-BR/server/entities.mdx
+++ b/content/docs/pt-BR/server/entities.mdx
@@ -1,11 +1,11 @@
 ---
-title: Entities
-description: List of all Entities in Hytale
+title: Entidades
+description: Lista de todas as entidades do Hytale.
 icon: List
 full: true
 ---
 
-This page contains a list of all Entities available to be used as a key in the AssetMap.
+Esta página contém uma lista de todas as entidades disponíveis para serem usadas como uma chave no `AssetMap`.
 
 - Antelope
 - Archaeopteryx
@@ -129,9 +129,9 @@ This page contains a list of all Entities available to be used as a key in the A
 - Golem_Crystal_Earth
 - Golem_Crystal_Flame
 - Golem_Crystal_Frost
-- Golem_Crystal_Sand
+-
 - Golem_Crystal_Thunder
-- Golem_Firesteel
+-
 - Golem_Guardian_Void
 - Grooble
 - Hatworm
diff --git a/content/docs/pt-BR/server/events.mdx b/content/docs/pt-BR/server/events.mdx
index ca7ed28f..5fc31ddb 100644
--- a/content/docs/pt-BR/server/events.mdx
+++ b/content/docs/pt-BR/server/events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Events
-description: List of all events in Hytale
+title: Eventos
+description: Lista de todos os eventos em Hytale.
 icon: List
 full: true
 ---
@@ -39,14 +39,14 @@ full: true
 - GenerateSchemaEvent
 - GenerateServerStateEvent
 - ItemContainerChangeEvent
-- ~~LivingEntityUseBlockEvent~~ DEPRECATED
+- ~~LivingEntityUseBlockEvent~~ OBSOLETO
 - LoadAssetEvent
 - LoadedNPCEvent
 - MessagesUpdated
 - PlayerConnectEvent
 - PlayerEvent
-  - ~~PlayerCraftEvent~~ DEPRECATED
-  - ~~PlayerInteractEvent~~ DEPRECATED
+  - ~~PlayerCraftEvent~~ OBSOLETO
+  - ~~PlayerInteractEvent~~ OBSOLETO
   - PlayerMouseButtonEvent
   - PlayerMouseMotionEvent
   - PlayerReadyEvent
@@ -57,7 +57,7 @@ full: true
 - PlayerSetupDisconnectEvent
 - PluginEvent
   - PluginSetupEvent
-- ~~PrepareUniverseEvent~~ DEPRECATED
+- ~~PrepareUniverseEvent~~ OBSOLETO
 - ShutdownEvent
 - SingleplayerRequestAccessEvent
 - TreasureChestOpeningEvent
@@ -97,8 +97,8 @@ full: true
 - DiscoverInstanceEvent
   - Display
 - DiscoverZoneEvent
-  - Display
-- MoonPhaseChangeEvent
+  -
+-
 - UseBlockEvent
   - Post
   - Pre
diff --git a/content/docs/pt-BR/server/sounds.mdx b/content/docs/pt-BR/server/sounds.mdx
index 5b54a035..4dbaf4e6 100644
--- a/content/docs/pt-BR/server/sounds.mdx
+++ b/content/docs/pt-BR/server/sounds.mdx
@@ -1,11 +1,11 @@
 ---
-title: Sounds
-description: List of all Sounds in Hytale
+title: Sons
+description: Lista de todos os sons em Hytale.
 icon: List
 full: true
 ---
 
-This page contains a list of all Sounds available to be used as a key in the AssetMap.
+Esta página contém uma lista de todos os sons disponíveis para serem usados como uma chave no `AssetMap`.
 
 - SFX_Alchemy_Bench_Close
 - SFX_Alchemy_Bench_Craft
@@ -22,9 +22,9 @@ This page contains a list of all Sounds available to be used as a key in the Ass
 - SFX_Armour_Bench_Craft
 - SFX_Armour_Bench_Open
 - SFX_Arrow_Fire_Hit
-- SFX_Arrow_Fire_Miss
+-
 - SFX_Arrow_Frost_Hit
-- SFX_Arrow_Frost_Miss
+-
 - SFX_Arrow_FullCharge_Hit
 - SFX_Arrow_FullCharge_Miss
 - SFX_Arrow_HalfCharge_Hit
diff --git a/content/docs/pt-PT/contributing/index.mdx b/content/docs/pt-PT/contributing/index.mdx
new file mode 100644
index 00000000..ac05eb21
--- /dev/null
+++ b/content/docs/pt-PT/contributing/index.mdx
@@ -0,0 +1,39 @@
+---
+title: Contributing
+---
+
+# Contributing to HytaleModding
+
+We welcome contributions from the community to help improve and expand the HytaleModding documentation. Whether you're fixing typos, adding new tutorials, or providing code examples, your contributions are valuable!
+
+## How to Contribute
+
+### Reporting Issues
+
+If you've found a issue with the documentation, please report it by opening a new issue on our [GitHub repository](https://github.com/HytaleModding/site/issues).
+
+If you can work on this issue yourself, you can ask to be assigned to it and submit a PR.
+
+### Submitting Pull Requests
+
+1. Fork the repository on GitHub.
+2. Clone your fork to your local machine.
+3. Create a new branch for your changes.
+
+```bash
+git checkout -b my-feature-branch
+```
+
+4. Make your changes and commit them with clear messages. We follow [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/), your PR will not be accepted if your commit messages do not follow this convention.
+
+```bash
+git commit -m "Add feature X to documentation"
+```
+
+5. Push your changes to your fork.
+
+```bash
+git push origin my-feature-branch
+```
+
+6. Open a Pull Request on the original repository, describing your changes and why they should be merged.
diff --git a/content/docs/pt-PT/contributing/pr-guidelines.mdx b/content/docs/pt-PT/contributing/pr-guidelines.mdx
new file mode 100644
index 00000000..7a251032
--- /dev/null
+++ b/content/docs/pt-PT/contributing/pr-guidelines.mdx
@@ -0,0 +1,39 @@
+---
+title: PR Guidelines
+description: Guidelines that reviewers and contributors should follow when submitting and reviewing pull requests.
+---
+
+# Pull Request Guidelines
+
+To ensure a smooth and efficient review process, both contributors and reviewers should adhere to the following guidelines when submitting and reviewing pull requests (PRs).
+
+## For Contributors
+
+1. **Descriptive Titles and Descriptions**
+   - Use clear and concise titles that summarize the changes.
+   - Provide detailed descriptions of what the PR does, why the changes are necessary, and any relevant context.
+2. **Link to Issues**
+   - In your PR title, add `GH-ISSUE-NUMBER` to link the PR to the relevant issue. This is required for all PRs.
+3. **Small, Focused Changes**
+   - Aim to keep PRs small and focused on a single issue or feature. This makes it easier for reviewers to understand and provide feedback.
+4. **Code Quality**
+   - Ensure your code follows the project's coding standards and best practices.
+   - Include comments where necessary to explain complex logic.
+5. **Testing**
+   - Test your changes thoroughly before submitting the PR.
+   - If applicable, include unit tests or integration tests to verify your changes.
+6. **Documentation**
+   - Update or add documentation as needed to reflect your changes.
+7. **Commit Messages**
+   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
+8. **Check for Conflicts**
+   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+
+## For Reviewers
+
+- You are supposed to review PRs thoroughly, and request changes if needed.
+- Provide constructive feedback and suggestions for improvement.
+- Verify that the changes meet the project's coding standards and best practices.
+- Deploy the PR using the dokploy integration to ensure the changes work as expected.
+- Ensure that documentation is updated as necessary.
+- Approve the PR only when you are satisfied with the changes and all checks have passed.
diff --git a/content/docs/pt-PT/contributing/writing-guides.mdx b/content/docs/pt-PT/contributing/writing-guides.mdx
new file mode 100644
index 00000000..55c52ade
--- /dev/null
+++ b/content/docs/pt-PT/contributing/writing-guides.mdx
@@ -0,0 +1,86 @@
+---
+title: Writing Guides
+---
+
+## Creating a guide file
+
+To start writing a guide, you need to create a file with extension `.mdx`. You need to create this file inside the `/content/docs/en` directory, now it depends in which section you want to make the guide, so you can decide which folder you should put it in after that.
+
+Suppose I want to make a java basics guide, I'd put it in `/content/docs/en/guides/java-basics`. You'll have to do some digging to find out where you want to place it.
+
+<Callout>
+  If there's already a guide in the section you want to write about, you can just press on the "Edit On GitHub" button on our website and it'll take you to the folder, now you can write in the same folder to have your guide appear in the same section.
+</Callout>
+
+## Frontmatter
+
+Frontmatter is the metadata of your guide, it tells our website how to display your guide. This needs to be at the very top of the file, which starts with `---` and ends with `---`.
+
+Here's an example:
+
+```mdx
+---
+title: "Java Basics"
+description: "Learn the basics of Java programming."
+authors:
+    - name: "Your Name"
+      url: "https://yourwebsite.com"
+---
+```
+
+Now as you can see, it's pretty self explanatory, you just need to fill in the details for your specific guide. If you don't have a URL you want to link yourself to, just don't write that whole line. Additionally, the authors section is optional, so if you don't want to add it, you can just leave it out although we encourage you to do so and credit yourself.
+
+The indentation in the frontmatter is important, so make sure to keep it consistent with the example.
+
+## Content Structure
+
+You should structure the content of your guide in a clear and organized manner. Here are some tips on how to do that:
+
+- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
+- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
+- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
+- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
+- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+
+Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+
+When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+
+## Formatting
+
+We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+
+- Use headings (`#`, `##`, `###`) to organize your content.
+- Use bullet points and numbered lists for clarity.
+- Use code blocks (\`\`\`) for code snippets.
+- Use links to reference other guides or external resources.
+
+This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+
+You can also make a Callout to highlight important information or tips. Use the following syntax:
+
+```mdx
+<Callout>
+    This is a callout message.
+</Callout>
+```
+
+<Callout>
+  This is a callout message.
+</Callout>
+
+You can change the color of the callout by adding a `type` attribute. For example:
+
+```mdx
+<Callout type="info">
+    This is an info callout.
+</Callout>
+```
+
+Available types are: `info`, `warning`, `error`, and `success`.
+
+## Conclusion
+
+That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+
+Happy writing!
diff --git a/content/docs/pt-PT/established-information/developer-qa-insights.mdx b/content/docs/pt-PT/established-information/developer-qa-insights.mdx
index 4cc9b63f..47915c97 100644
--- a/content/docs/pt-PT/established-information/developer-qa-insights.mdx
+++ b/content/docs/pt-PT/established-information/developer-qa-insights.mdx
@@ -17,6 +17,7 @@ This extensive Q&A session with Hytale developers reveals critical technical det
 * **Data Layer**: Current custom serialization format will be replaced post-launch
 * **Performance**: Multi-core support - each world has main thread + parallel execution
 * **Rendering**: OpenGL 3.3 for Mac compatibility, potential future Vulkan/Metal migration
+* **Tick Model**: Base server tick rate is 30 TPS by default; can be changed using server plugins.
 
 ### Security & Distribution
 
diff --git a/content/docs/pt-PT/established-information/gameplay/creative.mdx b/content/docs/pt-PT/established-information/gameplay/creative.mdx
new file mode 100644
index 00000000..c2c4e4b4
--- /dev/null
+++ b/content/docs/pt-PT/established-information/gameplay/creative.mdx
@@ -0,0 +1,243 @@
+---
+title: Creative
+description: Information regarding the creative mode in Hytale.
+---
+
+# Creative Mode
+
+Creative mode in Hytale is a sandbox mode that allows players to edit the world freely.
+
+## World Editing Tools
+
+Creative mode includes a variety of tools to help players edit the world. It includes undo functionality for edits.
+
+Note that the below sections were unnamed in the video demo of the tools.
+
+---
+
+### Laser Pointer
+
+Displays a ray from the player's camera in the direction the player is looking.
+
+#### Settings
+
+- Duration (Integer Slider): Description unknown as of December 2025.
+- Laser Color (Hex Color Code): Description unknown as of December 2025.
+
+### Sculpt Brush Tool
+
+Allows the user to raise and lower the terrain to more accurately sculpt and blend shapes. Supports most features of the Paint Brush.
+
+### Line Brush Tool
+
+Unknown as of December 2025.
+
+### Selection Tool
+
+Allows the user to select and edit regions of the world by transforming selections of blocks or a prefab via position, rotation, and extrusion.
+
+#### Settings
+
+- Mode (Combo Box: Set, Wall, Fill, Replace): Description unknown as of December 2025.
+- Material (Integer Slider): Description unknown as of December 2025.
+- Weight (Integer Slider): Description unknown as of December 2025.
+- Pitch (Integer): Description unknown as of December 2025.
+
+### Ruler
+
+Allows the user to measure distances between multiple points in 3D space, with support for multiple measurement lines and editing of measured points.
+
+### Layer Brush Tool
+
+Unknown as of December 2025.
+
+### Paste Tool
+
+Allows the user to paste a copied selection of blocks or a prefab at the point at which the player is looking. The paste is relative to the selection's anchor point. If the selection is a prefab, the anchor point may be set in the Prefab Editor. It is unknown if the selection's anchor may be set otherwise.
+
+### Flood Brush Tool
+
+Unknown as of December 2025.
+
+### Paint Brush Tool
+
+Brushes are used to make large changes to the world from far away.
+
+#### General Abilities
+
+- Place Shapes and Prefabs
+- Replace Blocks
+- Create Axis Locks and Masks
+
+#### Settings
+
+- Material
+- Width (Integer Slider): Description unknown as of December 2025.
+- Height (Integer Slider): Description unknown as of December 2025.
+- Shape (Combo Box: Cube, Sphere, Cylinder, Cone, Inverted Cone, Pyramid, Inverted Pyramid, Cuboid Grid): Description unknown as of December 2025.
+- Origin (Combo Box: Center, Bottom, Top): Description unknown as of December 2025.
+- Mirror Axis (Combo Box: None, Unknown other options): Description unknown as of December 2025.
+- Wall Thickness (Integer Slider): Description unknown as of December 2025.
+- Density (Integer Slider): Description unknown as of December 2025.
+
+#### Presets:
+
+- Boulder: Creates a boulder at the point at which the player is looking.
+- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
+- Rubble: Generate rubble at the point at which the player is looking.
+- Tentacle: TBD
+- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
+- Hot Springs: TBD
+- Ruins: Generates a ruin at the point at which the player is looking.
+- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
+- Grass: TBD
+- Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
+- Ruins: TBD
+
+---
+
+### Entity Grabber Tool
+
+Unknown as of December 2025.
+
+### Noise Brush Tool
+
+Unknown as of December 2025.
+
+### Scatter Brush Tool
+
+Unknown as of December 2025.
+
+### Extrude Brush Tool
+
+Unknown as of December 2025.
+
+### Prefab Selector Tool
+
+Allows the user to select a prefab when inside the Prefab Editor. May be used with the copy command.
+
+### Smooth Brush Tool
+
+Unknown as of December 2025.
+
+### Hitbox Tool
+
+Unknown as of December 2025.
+
+### Set Anchor Tool
+
+Allows the user to set an anchor point for a prefab when inside the Prefab Editor.
+
+### Tint Brush Tool
+
+Unknown as of December 2025.
+
+---
+
+## Creative Mode Quick Settings
+
+Note that these are WIP and subject to change. **Not all settings and functionality are currently known**.
+
+- Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
+- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
+- Brush Opacity (Integer Slider): Description unknown as of December 2025.
+- Selection Opacity (Integer Slider): Description unknown as of December 2025.
+- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
+- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
+- Display Legend (Toggle): Description unknown as of December 2025.
+- Show Tool Notifications (Toggle): Description unknown as of December 2025.
+- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
+- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
+- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
+- Flight Intertia (Integer Slider): Description unknown as of December 2025.
+- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
+- No Clip (Toggle): Description unknown as of December 2025.
+- Air Placement (Toggle): Description unknown as of December 2025.
+
+## Content Creation Tools
+
+Hytale includes a variety of built-in content creation tools to help players create and edit content.
+
+### Asset Editor
+
+Unknown as of December 2025.
+
+### Model Editor
+
+Unknown as of December 2025.
+
+### Asset Node Editor
+
+Unknown as of December 2025.
+
+### World Tools
+
+These are tools that allow the user to directly edit the current world.
+
+#### Prefab Editor
+
+Allows the user to create or edit prefabs in a separate space.
+
+##### Settings
+
+- Saved configs (Unknown type; presumably a file)
+- Root Dir (Unknown type; presumably a folder)
+- Prefab Paths or Folders (Unknown type; presumably a list of paths or folders)
+- Recursively Search for Prefabs (Toggle)
+- Spawn Entities and NPCs (Toggle)
+- Desired Y Level to Paste (Integer)
+- Blocks Between Prefabs (Integer)
+- WorldGen Type (Combo Box: Flat, Unknown other options): Description unknown as of December 2025.
+- (Flat WorldGen Only) Num Air Blocks Below Prefabs (Integer): Description unknown as of December 2025.
+- Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
+- Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
+
+#### Prefab List
+
+- Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
+- User can pick from server, assets, or worldgen prefabs.
+
+#### Spawn NPC
+
+Unknown as of December 2025.
+
+#### Spawn Particle
+
+Unknown as of December 2025.
+
+#### Change Player Model
+
+- Allows the player to change their model with an adjustable scale.
+
+#### Tint Chunk
+
+Unknown as of December 2025.
+
+#### Instances
+
+Unknown as of December 2025.
+
+### Builder Tools
+
+Unknown as of December 2025.
+
+### Machinima
+
+Machinima is a built-in sequence editor, allowing the user to create and edit sequences of actions to be played back in game. It includes a built-in interactive keyframe editor.
+
+The speed of playback can be adjusted via commands.
+
+The user may add actors for the sequence to control.
+
+- Reference
+- Camera
+- Entity
+- Item
+- Player
+
+## Commands
+
+Commands are entered into the world's chat console and begin with a forward slash `/`.
+
+- `set <block>`: allows the user to set the blocks in a selection to the specified block.
+- `inventory clear`: allows the user to clear their inventory.
diff --git a/content/docs/pt-PT/established-information/server-plugin-insights.mdx b/content/docs/pt-PT/established-information/server-plugin-insights.mdx
new file mode 100644
index 00000000..40c8ae52
--- /dev/null
+++ b/content/docs/pt-PT/established-information/server-plugin-insights.mdx
@@ -0,0 +1,93 @@
+---
+title: Server Code Insights
+description: Slikey shared some insights about server code on 12/15/2025. This document covers key points and takeaways from that discussion.
+---
+
+<Callout type="info" title="Note">
+  The following information is based on insights shared by Technical Director Slikey on December 15, 2025 on the Hytale Discord Server. It provides an overview of the server code architecture and plugin capabilities.
+
+  Majority of this document is just straight quotes from Slikey with minimal commentary. It is more over to preserve the information shared rather than reword it.
+</Callout>
+
+# Server Source Code
+
+The server will be released as shared source - we will have the source code with no obfuscation and all their comments.
+
+### License
+
+The license permits usage for any **hytale related** things, so as long as you dont use the server / source to make your own game or sell their algorithms.
+
+# Permission system
+
+After being asked in the Hytale Modding server, Lead Architect Zero has replied:
+
+It's quite basic, so don't expect much but yes we do have a permissions system built in. It also support implementing your own backend. Ex. if you wanted to store it in a database.
+
+![Premission Source Snippet](/assets/premission-system.png)
+
+# World Gen Implementation
+
+The following block of text is directly from Lead Architect Zero:
+
+You can totally implement a custom world gen in a plugin super easy. So if you want a totally different config or logic for generating terrain you can add that into a plugin and then configure a world to use that,
+We have some stuff load prefabs and there is existing code in the current world generators that could possibly be reused but no APIs specifically for the details of the generation itself.
+
+```java
+public interface IWorldGenProvider {
+    BuilderCodecMapCodec<IWorldGenProvider> CODEC = new BuilderCodecMapCodec<>("Type", true);
+
+    IWorldGen getGenerator() throws WorldGenLoadException;
+}
+```
+
+```java
+public interface IWorldGen {
+    @Nullable
+    WorldGenTimingsCollector getTimings();
+
+    CompletableFuture<GeneratedChunk> generate(int seed, long index, int x, int z, LongPredicate stillNeeded);
+
+    @Deprecated
+    Transform[] getSpawnPoints(int seed);
+
+    @Nonnull
+    default ISpawnProvider getDefaultSpawnProvider(int seed) {
+        return new FitToHeightMapSpawnProvider(new IndividualSpawnProvider(getSpawnPoints(seed)));
+    }
+
+    default void shutdown() {}
+}
+```
+
+# Server Code Snippets
+
+Some code snippets from a plugin they made were also shared. The following snippets are directly quoted from Technical Director Slikey:
+
+## BlockSpawner Plugin
+
+Alright, I'll drop some code snippets here for a simple plugin called "BlockSpawner" which will turn into a "random" block when put into the world based on the configured rules
+
+There is more code here in general but it shows the Asset System and the plugin layout. You can see that the asset system defines "Codecs" which are used to serialize and deserialize data. Using these codecs we can generate schemas.
+Let's say you connect to a server and open the asset editor: the server will send those schemas - so every single asset type defined server side, even you own, now become part of the asset editor on the client - no need to do anything, you just get to enjoy the editor UI for making your assets that you defined
+
+![Block Spawner Code 1](/assets/blockspawner-code-1.png)
+![Block Spawner Code 2](/assets/blockspawner-code-2.png)
+![Block Spawner Code 3](/assets/blockspawner-code-3.png)
+![Block Spawner Manifest](/assets/blockspawner-manifest.png)
+
+> i guess this part also shows a bit how we use constants to store some language keys - Slikey
+> (in reference to the image below)
+
+![Constants to store Language Keys](/assets/constants.png)
+
+> you can completely customize the chunk storage provider, we for example made one that is just empty where it doesnt load any chunks from disk
+> you could add an MySQLChunkStorageProvider and it could read the data from a database
+> and the same goes for worldgen, you can simply implement this interface to generate a world generator - slikey
+
+![Chunks 1](/assets/chunks-1.png)
+![Chunks 2](/assets/chunks-2.png)
+![Chunks 3](/assets/chunks-3.png)
+
+> i mean here are all the weapons defined, you tell me, obviously you will discover limitations but i think there is plenty of room to make changes - this stuff is actually hard though, there is a lot of QoL to have happen here
+
+![Weapons 1](/assets/weapons-1.png)
diff --git a/content/docs/pt-PT/guides/ecs/entity-component-system.mdx b/content/docs/pt-PT/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/pt-PT/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/pt-PT/guides/ecs/example-ecs-plugin.mdx b/content/docs/pt-PT/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/pt-PT/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/pt-PT/guides/ecs/hytale-ecs-theory.mdx b/content/docs/pt-PT/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/pt-PT/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/pt-PT/guides/ecs/systems.mdx b/content/docs/pt-PT/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/pt-PT/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/pt-PT/guides/java-basics/00-introduction.mdx b/content/docs/pt-PT/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/pt-PT/guides/java-basics/00-introduction.mdx
+++ b/content/docs/pt-PT/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/pt-PT/guides/java-basics/01-variables.mdx b/content/docs/pt-PT/guides/java-basics/01-variables.mdx
index 410eb152..f884cc02 100644
--- a/content/docs/pt-PT/guides/java-basics/01-variables.mdx
+++ b/content/docs/pt-PT/guides/java-basics/01-variables.mdx
@@ -18,10 +18,10 @@ A variable has three key components:
 In Java, you must declare a variable before using it, like you'd need a box before putting something in it. The syntax is:
 
 ```java
-int age;
-age = 18;
+int age; // A declaration
+age = 18; // An assignment
 
-int age = 18; // Declaration and assignment in one line
+int age = 18; // Declaration and assignment in one line, also considered an initialization
 ```
 
 ## Primitive Data Types
@@ -44,7 +44,7 @@ Sometimes you might not want a variable to stay the same type. You can convert b
 
 ```java
 int num = 10;
-double decimalNum = (double) num; // 10.0 - works automatically
+double decimalNum = num; // 10.0 - works automatically
 ```
 
 ### Manual (Casting)
diff --git a/content/docs/pt-PT/guides/java-basics/04-control-flow-loops.mdx b/content/docs/pt-PT/guides/java-basics/04-control-flow-loops.mdx
index 92c3ee1a..8ff5b509 100644
--- a/content/docs/pt-PT/guides/java-basics/04-control-flow-loops.mdx
+++ b/content/docs/pt-PT/guides/java-basics/04-control-flow-loops.mdx
@@ -1,5 +1,5 @@
 ---
-title: 05 - Control Flow Loops
+title: 04 - Control Flow Loops
 description: Learn how to repeat code efficiently using loops in Java
 ---
 
diff --git a/content/docs/pt-PT/guides/java-basics/06-methods-functions.mdx b/content/docs/pt-PT/guides/java-basics/06-methods-functions.mdx
new file mode 100644
index 00000000..e8e60761
--- /dev/null
+++ b/content/docs/pt-PT/guides/java-basics/06-methods-functions.mdx
@@ -0,0 +1,432 @@
+---
+title: 06 - Methods (Functions)
+description: Learn how to organize and reuse code with methods.
+---
+
+Methods are reusable blocks of code that perform specific tasks. They help you avoid repeating code and make your programs easier to understand.
+
+## What is a Method?
+
+Think of a method as a recipe. You define it once, then use it whenever you need it.
+
+```java tab="Code"
+public class Game {
+    public static void main(String[] args) {
+        greet();        // Call the method
+        greet();        // Call it again!
+    }
+    
+    // Method definition
+    public static void greet() {
+        System.out.println("Welcome to Hytale!");
+    }
+}
+```
+
+```text tab="Output"
+Welcome to Hytale!
+Welcome to Hytale!
+```
+
+## Method Structure
+
+```java
+public static void methodName() {
+//  ^      ^     ^      ^       ^
+//  |      |     |      |       |
+// access static return name  parameters
+// modifier       type
+    // Code goes here
+}
+```
+
+We'll learn what `public` and `static` mean later. For now, just use them.
+
+## Methods with Parameters
+
+Parameters let you pass data into methods:
+
+```java
+public static void greetPlayer(String name) {
+    System.out.println("Hello, " + name + "!");
+}
+
+public static void main(String[] args) {
+    greetPlayer("Alice");  // Hello, Alice!
+    greetPlayer("Bob");    // Hello, Bob!
+}
+```
+
+### Multiple Parameters
+
+```java
+public static void dealDamage(String target, int damage) {
+    System.out.println(target + " takes " + damage + " damage!");
+}
+
+public static void main(String[] args) {
+    dealDamage("Zombie", 20);    // Zombie takes 20 damage!
+    dealDamage("Skeleton", 15);  // Skeleton takes 15 damage!
+}
+```
+
+<Callout type="info" title="Parameter Order Matters">
+  When calling a method, arguments must match the parameter order:
+
+  ```java
+  public static void createItem(String name, int quantity, double price) {
+      // ...
+  }
+
+  // Correct
+  createItem("Sword", 1, 50.0);
+
+  // Wrong - Order matters!
+  createItem(1, "Sword", 50.0);  // Error!
+  ```
+</Callout>
+
+## Methods with Return Values
+
+Methods can send data back using `return`:
+
+```java
+public static int add(int a, int b) {
+    int sum = a + b;
+    return sum;
+}
+
+public static void main(String[] args) {
+    int result = add(5, 3);
+    System.out.println(result);  // 8
+}
+```
+
+The return type must match what you return:
+
+* `void` - Returns nothing
+* `int` - Returns an integer
+* `double` - Returns a decimal
+* `boolean` - Returns true/false
+* `String` - Returns text
+
+```java
+public static String getItemName() {
+    return "Diamond Sword";
+}
+
+public static boolean isPlayerAlive(int health) {
+    return health > 0;
+}
+
+public static double calculateDamage(int attack, double multiplier) {
+    return attack * multiplier;
+}
+```
+
+<Callout type="warning" title="Return Stops Execution">
+  Once a method hits `return`, it immediately exits. Code after `return` won't run!
+
+  ```java
+  public static int getValue() {
+      return 10;
+      System.out.println("This never runs!");  // Unreachable code!
+  }
+  ```
+</Callout>
+
+## Practical Examples
+
+### Health System
+
+```java tab="Code"
+public static void displayHealth(String name, int health, int maxHealth) {
+    double percentage = (health * 100.0) / maxHealth;
+    System.out.println(name + ": " + health + "/" + maxHealth + 
+                      " (" + percentage + "%)");
+}
+
+public static void main(String[] args) {
+    displayHealth("Player", 75, 100);
+    displayHealth("Boss", 450, 500);
+}
+```
+
+```text tab="Output"
+Player: 75/100 (75.0%)
+Boss: 450/500 (90.0%)
+```
+
+### Damage Calculator
+
+```java tab="Code"
+public static int calculateDamage(int baseAttack, int weaponDamage, boolean isCritical) {
+    int totalDamage = baseAttack + weaponDamage;
+    
+    if (isCritical) {
+        totalDamage *= 2;
+    }
+    
+    return totalDamage;
+}
+
+public static void main(String[] args) {
+    int damage1 = calculateDamage(10, 15, false);  // 25
+    int damage2 = calculateDamage(10, 15, true);   // 50
+    
+    System.out.println("Normal hit: " + damage1);
+    System.out.println("Critical hit: " + damage2);
+}
+```
+
+### Level Requirements
+
+```java tab="Code"
+public static int getXPForLevel(int level) {
+    return level * 100;
+}
+
+public static boolean canLevelUp(int currentXP, int currentLevel) {
+    int required = getXPForLevel(currentLevel + 1);
+    return currentXP >= required;
+}
+
+public static void main(String[] args) {
+    int playerXP = 450;
+    int playerLevel = 4;
+    
+    if (canLevelUp(playerXP, playerLevel)) {
+        System.out.println("You can level up!");
+    } else {
+        int needed = getXPForLevel(playerLevel + 1) - playerXP;
+        System.out.println("Need " + needed + " more XP");
+    }
+}
+```
+
+### Distance Calculator
+
+```java tab="Code"
+public static double calculateDistance(int x1, int y1, int x2, int y2) {
+    int dx = x2 - x1;
+    int dy = y2 - y1;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+public static boolean isInRange(int x1, int y1, int x2, int y2, double range) {
+    double distance = calculateDistance(x1, y1, x2, y2);
+    return distance <= range;
+}
+
+public static void main(String[] args) {
+    // Check if enemy is in attack range
+    if (isInRange(0, 0, 5, 5, 10.0)) {
+        System.out.println("Target in range!");
+    }
+}
+```
+
+## Method Overloading
+
+You can have multiple methods with the same name but different parameters:
+
+```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
+}
+```
+
+<Callout type="info" title="Method Overloading Rules">
+  Methods are considered different if they have:
+
+  * Different number of parameters
+  * Different types of parameters
+  * Different order of parameters
+
+  ```java
+  public static void test(int a) { }
+  public static void test(int a, int b) { }        // Different count
+  public static void test(double a) { }            // Different type
+  public static void test(String a, int b) { }     // Different types
+  public static void test(int a, String b) { }     // Different order
+
+  // Wrong - Only return type is different
+  public static int test(int a) { }
+  ```
+</Callout>
+
+## Common Patterns in Hytale Modding
+
+### Item Creation
+
+```java
+public static Item createItem(String name, int durability) {
+    Item item = new Item();
+    item.setName(name);
+    item.setDurability(durability);
+    return item;
+}
+
+public static Item createSword() {
+    return createItem("Sword", 100);
+}
+
+public static Item createPickaxe() {
+    return createItem("Pickaxe", 150);
+}
+```
+
+### Block Placement Validation
+
+```java
+public static boolean canPlaceBlock(int x, int y, int z) {
+    // Check if position is valid
+    if (y < 0 || y > 255) {
+        return false;
+    }
+    
+    // Check if block already exists
+    if (isBlockAt(x, y, z)) {
+        return false;
+    }
+    
+    return true;
+}
+
+public static void placeBlock(int x, int y, int z, String type) {
+    if (canPlaceBlock(x, y, z)) {
+        // Place the block
+        System.out.println("Placed " + type + " at (" + x + ", " + y + ", " + z + ")");
+    } else {
+        System.out.println("Cannot place block there!");
+    }
+}
+```
+
+### Player State Checks
+
+```java
+public static boolean isLowHealth(int health, int maxHealth) {
+    return (health * 100.0 / maxHealth) < 25;
+}
+
+public static String getHealthStatus(int health, int maxHealth) {
+    double percentage = (health * 100.0) / maxHealth;
+    
+    if (percentage >= 75) {
+        return "Healthy";
+    } else if (percentage >= 50) {
+        return "Injured";
+    } else if (percentage >= 25) {
+        return "Critical";
+    } else {
+        return "Near Death";
+    }
+}
+```
+
+## Best Practices
+
+<Callout type="info" title="Method Naming">
+  Use descriptive verb-based names that explain what the method does:
+
+  ```java
+  // Good
+  public static void calculateDamage() { }
+  public static boolean isPlayerAlive() { }
+  public static String getItemName() { }
+  public static void displayInventory() { }
+
+  // Bad
+  public static void dmg() { }        // Too short
+  public static void method1() { }    // Not descriptive
+  public static void stuff() { }      // Too vague
+  ```
+</Callout>
+
+## Practice Exercises
+
+1. **Temperature Converter**: Write methods to convert:
+   * Celsius to Fahrenheit: `(C × 9/5) + 32`
+   * Fahrenheit to Celsius: `(F - 32) × 5/9`
+
+2. **Circle Calculator**: Create methods that calculate:
+   * Area: `π × radius²`
+   * Circumference: `2 × π × radius`
+   * Use `Math.PI` for π
+
+3. **Item Durability**: Write these methods:
+   * `damageItem(int current, int damage)` - returns new durability
+   * `isBroken(int durability)` - returns true if durability is less than or equal to 0
+   * `repairItem(int current, int max)` - returns max durability
+
+4. **Password Validator**: Create a method that checks if a password is valid:
+   * At least 8 characters long
+   * Contains at least one number
+   * Returns true if valid, false otherwise
+
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
+## Common Mistakes
+
+```java
+// Wrong - Forgetting return statement
+public static int getValue() {
+    int x = 10;
+    // Forgot to return!
+} !
+
+// Correct
+public static int getValue() {
+    int x = 10;
+    return x;
+}
+
+// Wrong - Wrong return type
+public static int getText() {
+    return "Hello";  // Error! Should return int, not String
+}
+
+// Correct
+public static String getText() {
+    return "Hello";
+}
+
+// Wrong - Not calling the method
+public static void main(String[] args) {
+    greet;  // Error! Missing ()
+}
+
+// Correct
+public static void main(String[] args) {
+    greet();
+}
+```
+
+---
diff --git a/content/docs/pt-PT/guides/java-basics/07-introduction-oop.mdx b/content/docs/pt-PT/guides/java-basics/07-introduction-oop.mdx
new file mode 100644
index 00000000..058b7e5e
--- /dev/null
+++ b/content/docs/pt-PT/guides/java-basics/07-introduction-oop.mdx
@@ -0,0 +1,378 @@
+---
+title: 07 - Introduction to Object-Oriented Programming
+description: Learn the fundamentals of classes and objects in Java.
+---
+
+Object-Oriented Programming (OOP) is the foundation of Java and Hytale modding. Instead of just having variables and methods floating around, we organize them into **classes** and **objects**.
+
+## What is a Class?
+
+A class is a blueprint for creating objects. Think of it like a recipe or a template.
+
+```java
+public class Player {
+    // Properties (data)
+    String name;
+    int health;
+    int level;
+    
+    // Behavior (methods)
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+    }
+}
+```
+
+## What is an Object?
+
+An object is an instance created from a class. If a class is a blueprint, an object is the actual thing built from that blueprint.
+
+```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!
+    }
+}
+```
+
+<Callout type="info" title="Class vs Object">
+  **Class** = Blueprint (the idea of a player)
+  **Object** = Actual thing (Alice, Bob, specific players)
+
+  One class can create many objects, just like one recipe can make many cakes!
+</Callout>
+
+## Creating a Simple Class
+
+Let's create a `Sword` class for Hytale:
+
+```java
+public class Sword {
+    // Properties
+    String name;
+    int damage;
+    int durability;
+    
+    // Method to use the sword
+    public void attack(String target) {
+        System.out.println("Attacking " + target + " for " + damage + " damage!");
+        durability -= 1;
+        
+        if (durability <= 0) {
+            System.out.println(name + " broke!");
+        }
+    }
+    
+    // Method to display info
+    public void displayInfo() {
+        System.out.println("Weapon: " + name);
+        System.out.println("Damage: " + damage);
+        System.out.println("Durability: " + durability);
+    }
+}
+```
+
+Using the class:
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Sword sword = new Sword();
+        sword.name = "Iron Sword";
+        sword.damage = 15;
+        sword.durability = 3;
+        
+        sword.displayInfo();
+        sword.attack("Zombie");
+        sword.attack("Skeleton");
+        sword.attack("Spider");  // This will break the sword
+    }
+}
+```
+
+## Constructors
+
+Instead of setting properties one by one, use a **constructor** to initialize objects:
+
+```java
+public class Sword {
+    String name;
+    int damage;
+    int durability;
+    
+    // Constructor
+    public Sword(String weaponName, int weaponDamage, int weaponDurability) {
+        name = weaponName;
+        damage = weaponDamage;
+        durability = weaponDurability;
+    }
+    
+    public void attack(String target) {
+        System.out.println("Attacking " + target + " for " + damage + " damage!");
+        durability--;
+    }
+}
+```
+
+Now creating swords is easier:
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        // Much cleaner!
+        Sword ironSword = new Sword("Iron Sword", 15, 100);
+        Sword diamondSword = new Sword("Diamond Sword", 25, 200);
+        
+        ironSword.attack("Zombie");
+        diamondSword.attack("Boss");
+    }
+}
+```
+
+<Callout type="info" title="Constructor Rules">
+  * Same name as the class
+  * No return type (not even `void`)
+  * Called automatically when you use `new`
+  * Can have multiple constructors (overloading)
+
+  ```java
+  public class Item {
+      String name;
+      int value;
+      
+      // Constructor with all parameters
+      public Item(String name, int value) {
+          this.name = name;
+          this.value = value;
+      }
+      
+      // Constructor with just name
+      public Item(String name) {
+          this.name = name;
+          this.value = 0;  // Default value
+      }
+  }
+  ```
+</Callout>
+
+## The `this` Keyword
+
+`this` refers to the current object. Use it to clarify when parameter names match property names:
+
+```java
+public class Player {
+    String name;
+    int health;
+    
+    public Player(String name, int health) {
+        this.name = name;      // this.name = the property
+        this.health = health;  // name = the parameter
+    }
+}
+```
+
+Without `this`, Java gets confused:
+
+```java
+public Player(String name, int health) {
+    name = name;      // ❌ Which name? Ambiguous!
+    health = health;  // ❌ Which health? Ambiguous!
+}
+```
+
+## Practical Examples
+
+### Item Class
+
+```java
+public class Item {
+    String name;
+    String type;
+    int quantity;
+    double weight;
+    
+    public Item(String name, String type, int quantity, double weight) {
+        this.name = name;
+        this.type = type;
+        this.quantity = quantity;
+        this.weight = weight;
+    }
+    
+    public void use() {
+        if (quantity > 0) {
+            quantity--;
+            System.out.println("Used " + name + ". Remaining: " + quantity);
+        } else {
+            System.out.println("No more " + name + " left!");
+        }
+    }
+    
+    public double getTotalWeight() {
+        return weight * quantity;
+    }
+}
+```
+
+```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
+    }
+}
+```
+
+### Monster Class
+
+```java
+public class Monster {
+    String name;
+    int health;
+    int attack;
+    boolean isHostile;
+    
+    public Monster(String name, int health, int attack, boolean isHostile) {
+        this.name = name;
+        this.health = health;
+        this.attack = attack;
+        this.isHostile = isHostile;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+        
+        if (health <= 0) {
+            System.out.println(name + " was defeated!");
+        } else {
+            System.out.println(name + " has " + health + " health left.");
+        }
+    }
+    
+    public int attackPlayer() {
+        if (isHostile && health > 0) {
+            System.out.println(name + " attacks for " + attack + " damage!");
+            return attack;
+        }
+        return 0;
+    }
+    
+    public boolean isAlive() {
+        return health > 0;
+    }
+}
+```
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Monster zombie = new Monster("Zombie", 50, 10, true);
+        Monster chicken = new Monster("Chicken", 10, 0, false);
+        
+        zombie.takeDamage(20);        // Zombie took 20 damage!
+        int damage = zombie.attackPlayer();  // Zombie attacks for 10 damage!
+        
+        if (zombie.isAlive()) {
+            System.out.println("Monster is still alive!");
+        }
+    }
+}
+```
+
+### Block Class
+
+```java
+public class Block {
+    String type;
+    int x, y, z;
+    boolean isSolid;
+    int hardness;
+    
+    public Block(String type, int x, int y, int z, boolean isSolid, int hardness) {
+        this.type = type;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.isSolid = isSolid;
+        this.hardness = hardness;
+    }
+    
+    public void breakBlock() {
+        System.out.println("Breaking " + type + " block at (" + x + ", " + y + ", " + z + ")");
+        System.out.println("Hardness: " + hardness);
+    }
+    
+    public String getPosition() {
+        return "(" + x + ", " + y + ", " + z + ")";
+    }
+    
+    public boolean canWalkThrough() {
+        return !isSolid;
+    }
+}
+```
+
+## Access Modifiers (Preview)
+
+You've seen `public` - it means "anyone can access this". We'll learn more about access control later, but here's a preview:
+
+```java
+public class Example {
+    public String publicVar;      // Anyone can access
+    private String privateVar;    // Only this class can access
+    /* (no modifier) */ String defaultVar; // Package access
+}
+```
+
+For now, use `public` for everything. We'll learn when to use `private` in the next article.
+
+<Callout type="info" title="Why Use Classes?">
+  Classes help you:
+
+  * **Organize** related data and methods together
+  * **Reuse** code easily (create many objects from one class)
+  * **Model** real-world things (players, items, monsters)
+  * **Maintain** code (changes in one place affect all objects)
+
+  Without classes, managing 100 players would require 100 separate variables for each property. With classes, it's just 100 Player objects!
+</Callout>
+
+## Practice Exercises
+
+1. **Create a `Potion` Class**:
+   * Properties: name, healAmount, uses
+   * Constructor to set all properties
+   * Method `drink()` that heals and decreases uses
+   * Method `isEmpty()` that returns true if uses less than or equal to 0
+
+2. **Create a `Chest` Class**:
+   * Properties: isLocked, itemCount, capacity
+   * Constructor
+   * Method `addItem()` that checks capacity
+   * Method `unlock()` that sets isLocked to false
+   * Method `isFull()` that checks if itemCount >= capacity
+
+3. **Create a `Villager` Class**:
+   * Properties: name, profession, tradeCount
+   * Constructor
+   * Method `greet()` that prints a greeting
+   * Method `trade()` that increases tradeCount
+   * Method `getInfo()` that displays all properties
+
+4. **Create Multiple Objects**: Using any class you made, create 3 different objects and test all their methods.
diff --git a/content/docs/pt-PT/guides/java-basics/08-access-modifiers.mdx b/content/docs/pt-PT/guides/java-basics/08-access-modifiers.mdx
new file mode 100644
index 00000000..af560932
--- /dev/null
+++ b/content/docs/pt-PT/guides/java-basics/08-access-modifiers.mdx
@@ -0,0 +1,595 @@
+---
+title: 08 - Encapsulation and Access Modifiers
+description: Learn how to protect and control access to your class data.
+---
+
+Encapsulation is about hiding the internal details of a class and controlling how its data is accessed and modified. This prevents bugs and makes your code more maintainable.
+
+## The Problem Without Encapsulation
+
+```java
+public class Player {
+    public String name;
+    public int health;
+    public int maxHealth;
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Player player = new Player();
+        player.health = 100;
+        player.maxHealth = 100;
+        
+        // Oops! Someone can break the rules
+        player.health = 500;      // Health over maximum!
+        player.health = -50;      // Negative health!
+        player.name = "";         // Empty name!
+    }
+}
+```
+
+Without protection, anyone can set invalid values!
+
+## Access Modifiers
+
+Java has keywords that control who can access your class members:
+
+| Modifier    | Class | Package | Subclass | World |
+| ----------- | ----- | ------- | -------- | ----- |
+| `public`    | ✓     | ✓       | ✓        | ✓     |
+| `protected` | ✓     | ✓       | ✓        | ✗     |
+| (none)      | ✓     | ✓       | ✗        | ✗     |
+| `private`   | ✓     | ✗       | ✗        | ✗     |
+
+**For now, focus on:**
+
+* `public` - Anyone can access
+* `private` - Only this class can access
+
+## Making Properties Private
+
+```java
+public class Player {
+    private String name;
+    private int health;
+    private int maxHealth;
+    
+    public Player(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+}
+```
+
+Now you can't access properties directly:
+
+```java
+Player player = new Player("Alice", 100);
+player.health = 500;  // ❌ Error! health is private
+```
+
+## Getters and Setters
+
+To access private properties, create **getter** and **setter** methods:
+
+```java
+public class Player {
+    private String name;
+    private int health;
+    private int maxHealth;
+    
+    public Player(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+    
+    // Getter - returns the value
+    public int getHealth() {
+        return health;
+    }
+    
+    // Setter - sets the value with validation
+    public void setHealth(int health) {
+        if (health < 0) {
+            this.health = 0;
+        } else if (health > maxHealth) {
+            this.health = maxHealth;
+        } else {
+            this.health = health;
+        }
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public int getMaxHealth() {
+        return maxHealth;
+    }
+}
+```
+
+Now you can safely interact with the object:
+
+```java
+Player player = new Player("Alice", 100);
+
+player.setHealth(150);  // Automatically capped at 100
+System.out.println(player.getHealth());  // 100
+
+player.setHealth(-20);  // Automatically set to 0
+System.out.println(player.getHealth());  // 0
+```
+
+<Callout type="info" title="Getter and Setter Naming">
+  Follow Java naming conventions:
+
+  * **Getter**: `get` + property name (capitalized)
+  * **Setter**: `set` + property name (capitalized)
+  * **Boolean**: `is` + property name (capitalized)
+
+  ```java
+  private int health;
+  public int getHealth() { }
+  public void setHealth(int health) { }
+
+  private boolean alive;
+  public boolean isAlive() { }
+  public void setAlive(boolean alive) { }
+
+  private String name;
+  public String getName() { }
+  public void setName(String name) { }
+  ```
+</Callout>
+
+## Benefits of Encapsulation
+
+### 1. Validation
+
+```java
+public class Item {
+    private int durability;
+    private int maxDurability;
+    
+    public void setDurability(int durability) {
+        if (durability < 0) {
+            this.durability = 0;
+        } else if (durability > maxDurability) {
+            this.durability = maxDurability;
+        } else {
+            this.durability = durability;
+        }
+    }
+    
+    public boolean isBroken() {
+        return durability <= 0;
+    }
+}
+```
+
+### 2. Read-Only Properties
+
+Sometimes you don't want a setter:
+
+```java
+public class Monster {
+    private String id;  // Should never change
+    private int health;
+    
+    public Monster(String id, int health) {
+        this.id = id;
+        this.health = health;
+    }
+    
+    // Getter only - no setter!
+    public String getId() {
+        return id;
+    }
+    
+    public int getHealth() {
+        return health;
+    }
+    
+    public void setHealth(int health) {
+        this.health = health;
+    }
+}
+```
+
+### 3. Computed Properties
+
+Getters don't have to return a field directly:
+
+```java
+public class Player {
+    private int health;
+    private int maxHealth;
+    
+    public int getHealth() {
+        return health;
+    }
+    
+    // Computed property
+    public double getHealthPercentage() {
+        return (health * 100.0) / maxHealth;
+    }
+    
+    // Computed property
+    public boolean isLowHealth() {
+        return getHealthPercentage() < 25;
+    }
+}
+```
+
+## Practical Examples
+
+### Item with Durability
+
+```java
+public class Tool {
+    private String name;
+    private int durability;
+    private int maxDurability;
+    private boolean broken;
+    
+    public Tool(String name, int maxDurability) {
+        this.name = name;
+        this.durability = maxDurability;
+        this.maxDurability = maxDurability;
+        this.broken = false;
+    }
+    
+    public void use() {
+        if (broken) {
+            System.out.println(name + " is broken!");
+            return;
+        }
+        
+        durability--;
+        System.out.println(name + " used. Durability: " + durability);
+        
+        if (durability <= 0) {
+            broken = true;
+            System.out.println(name + " broke!");
+        }
+    }
+    
+    public void repair() {
+        durability = maxDurability;
+        broken = false;
+        System.out.println(name + " repaired!");
+    }
+    
+    // Getters
+    public String getName() {
+        return name;
+    }
+    
+    public int getDurability() {
+        return durability;
+    }
+    
+    public boolean isBroken() {
+        return broken;
+    }
+    
+    public double getDurabilityPercentage() {
+        return (durability * 100.0) / maxDurability;
+    }
+}
+```
+
+### Bank Account Example
+
+```java
+public class PlayerWallet {
+    private int gold;
+    private int silver;
+    
+    public PlayerWallet() {
+        this.gold = 0;
+        this.silver = 0;
+    }
+    
+    public void addGold(int amount) {
+        if (amount > 0) {
+            gold += amount;
+            System.out.println("Added " + amount + " gold");
+        }
+    }
+    
+    public boolean spendGold(int amount) {
+        if (amount > gold) {
+            System.out.println("Not enough gold!");
+            return false;
+        }
+        
+        gold -= amount;
+        System.out.println("Spent " + amount + " gold");
+        return true;
+    }
+    
+    public int getGold() {
+        return gold;
+    }
+    
+    public int getTotalValue() {
+        // 1 gold = 100 silver
+        return gold * 100 + silver;
+    }
+}
+```
+
+### Protected Block System
+
+```java
+public class ProtectedBlock {
+    private int x, y, z;
+    private String type;
+    private String owner;
+    private boolean locked;
+    
+    public ProtectedBlock(int x, int y, int z, String type, String owner) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.type = type;
+        this.owner = owner;
+        this.locked = true;
+    }
+    
+    public boolean canBreak(String playerName) {
+        if (!locked) {
+            return true;
+        }
+        
+        return playerName.equals(owner);
+    }
+    
+    public void unlock(String playerName) {
+        if (playerName.equals(owner)) {
+            locked = false;
+            System.out.println("Block unlocked");
+        } else {
+            System.out.println("You don't own this block!");
+        }
+    }
+    
+    // Getters only - position and owner shouldn't change
+    public int getX() {
+        return x;
+    }
+    
+    public int getY() {
+        return y;
+    }
+    
+    public int getZ() {
+        return z;
+    }
+    
+    public String getOwner() {
+        return owner;
+    }
+    
+    public boolean isLocked() {
+        return locked;
+    }
+}
+```
+
+## When to Use Private vs Public
+
+<Callout type="info" title="General Rules">
+  **Make it private by default!** Only make things public if they need to be accessed from outside.
+
+  **Private:**
+
+  * Internal data (health, position, inventory)
+  * Helper methods used only within the class
+  * Anything that needs validation
+
+  **Public:**
+
+  * Methods that define the class's behavior
+  * Constructor
+  * Methods other classes need to call
+
+  ```java
+  public class Example {
+      // Private - internal data
+      private int internalCounter;
+      private String secretKey;
+      
+      // Public - part of the interface
+      public void doSomething() {
+          // Uses private helper method
+          validateData();
+      }
+      
+      // Private - internal helper
+      private void validateData() {
+          // ...
+      }
+  }
+  ```
+</Callout>
+
+## The `final` Keyword
+
+`final` means a variable can't be changed after it's set:
+
+```java
+public class Player {
+    private final String id;  // Can't change after creation
+    private String name;      // Can change
+    private int health;       // Can change
+    
+    public Player(String id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+    
+    public String getId() {
+        return id;
+    }
+    
+    // No setId() - it's final!
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+```
+
+## The `static` Keyword
+
+### Static Members
+
+A class can define two kinds of members:
+
+* **Instance members** — owned by each object (each instance has its own copy).
+
+* **Static members** — owned by the class (one shared copy for the entire type).
+
+Put simply: instance members belong to objects; static members belong to the class itself and are shared by all objects of that type.
+
+#### Declaration
+
+```java
+    /* (access modifier) */ static ... memberName; 
+```
+
+#### Example
+
+```java
+class Data {
+    public int x; // Instanced member
+    public static int y = 1000; // Static member
+
+    // Instanced member:
+    // can access to both static and non-static members
+    public void foo() {
+        x = 100; // OK - same as this.x = 100;
+        y = 100; // OK - same as Data.y = 200;
+    }
+
+    // Static member:
+    // cannot access to non-static variables
+    public static void bar() {
+        x = 100; // Error: non-static variable x cannot be renference from a static context
+        y = 100; // OK
+    }
+}
+```
+
+#### Accessing static members
+
+```java
+Data data = new Data();
+data.x = 1000; // OK
+
+data.y = 1000; // OK-ish - not really suggested; it's better to use Data.y
+Data.y = 1000; // OK - best practice
+
+Data.x = 1000; // Error: cannot access instanced variables in a static context
+```
+
+### Static Fields
+
+A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+
+It is declared as following:
+
+```java
+/* (access modifier) (optional) */ static /* final/volatile (optional) */ fieldName;
+```
+
+Let's take the same Data class example and add this constructor:
+
+```java
+public Data() {
+    y++; // remember that's the same as Data.y++;
+}
+```
+
+```java
+// Every instance of Data will have a private copy of the instanced member x
+// However it will point to the same location in memory for the member y
+Data d1 = new Data(); // y = 1001
+d1.x = 5;
+Data d2 = new Data(); // y = 1002
+d2.x = 25;
+Data d3 = new Data(); // y = 1003
+// ... and so on
+```
+
+### Static Methods
+
+Static methods essentially represent a function member of a certain class type
+
+From the Data class remember the function (instanced method) `foo` and (static method) `bar`
+
+One can access those methods via:
+
+```java
+Data d1 = new Data();
+
+d1.foo(); // Instanced method: Accessible ONLY by an object
+
+Data.bar(); // Static method: accessible without an object
+```
+
+### Static Initializer
+
+Use a *static initializer* block to run initialization logic when the class is first loaded:
+
+```java
+class OtherData {
+    private static int a = 12;
+    private static int b;
+    private static String msg;
+
+    static {
+        msg = "Initialization..."
+        System.out.println(msg);
+        b = 4;
+        // ... complex initialization that can't be done in a single expression
+    }
+}
+```
+
+## Practice Exercises
+
+1. **Create a `BankAccount` Class**:
+   * Private properties: accountNumber, balance
+   * Constructor to set account number
+   * Methods: deposit(), withdraw(), getBalance()
+   * Validation: can't withdraw more than balance
+   * Account number should be read-only
+
+2. **Create a `Door` Class**:
+   * Private properties: isLocked, keyCode
+   * Constructor to set the key code
+   * Methods: lock(), unlock(String code), isLocked()
+   * unlock() only works with correct code
+   * Code should be private (don't expose it!)
+
+3. **Create a `PlayerStats` Class**:
+   * Private properties: strength, defense, speed
+   * Constructor to set all stats
+   * Getters for all stats
+   * Method: getPowerLevel() that returns strength + defense + speed
+   * Stats can't be negative or over 100
+
+4. **Refactor a Class**: Take one of your classes from the previous lesson and add proper encapsulation:
+   * Make all properties private
+   * Add appropriate getters and setters
+   * Add validation where needed
diff --git a/content/docs/pt-PT/guides/java-basics/09-string.mdx b/content/docs/pt-PT/guides/java-basics/09-string.mdx
new file mode 100644
index 00000000..a374811b
--- /dev/null
+++ b/content/docs/pt-PT/guides/java-basics/09-string.mdx
@@ -0,0 +1,493 @@
+---
+title: 09 - Working with Strings
+description: Master text manipulation and string operations in Java.
+---
+
+Strings are one of the most commonly used types in Java. They're essential for handling player names, chat messages, item descriptions, and like everything you see.
+
+## String Basics
+
+Strings are objects that store text:
+
+```java
+String name = "Simon";
+String message = "Welcome to Hytale!";
+String empty = "";
+```
+
+<Callout type="warning" title="Strings are Immutable">
+  Once created, a String **cannot be changed**. Methods that seem to modify a string actually create a new one!
+
+  ```java
+  String text = "Hello";
+  text.toUpperCase();           // Creates "HELLO" but doesn't save it
+  System.out.println(text);     // Still "Hello"
+
+  String upper = text.toUpperCase();  // ✓ Save the result
+  System.out.println(upper);          // "HELLO"
+  ```
+</Callout>
+
+## String Methods
+
+### Length
+
+```java
+String name = "Alice";
+int length = name.length();
+System.out.println(length);  // 5
+```
+
+### Changing Case
+
+```java
+String text = "Hello World";
+String upper = text.toUpperCase();  // "HELLO WORLD"
+String lower = text.toLowerCase();  // "hello world"
+```
+
+### Checking Contents
+
+```java
+String message = "Welcome to Hytale";
+
+boolean hasHytale = message.contains("Hytale");  // true
+boolean hasMinecraft = message.contains("Minecraft");  // false
+
+boolean starts = message.startsWith("Welcome");  // true
+boolean ends = message.endsWith("Hytale");  // true
+```
+
+### Extracting Parts
+
+```java
+String text = "Hello World";
+
+char first = text.charAt(0);      // 'H'
+char last = text.charAt(10);      // 'd'
+
+String sub1 = text.substring(0, 5);   // "Hello"
+String sub2 = text.substring(6);      // "World"
+```
+
+<Callout type="info" title="Substring Indices">
+  `substring(start, end)` includes `start` but excludes `end`:
+
+  ```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)
+  ```
+</Callout>
+
+### Replacing Text
+
+```java
+String text = "I love Minecraft";
+String replaced = text.replace("Minecraft", "Hytale");
+System.out.println(replaced);  // "I love Hytale"
+
+String noSpaces = "Hello World".replace(" ", "");
+System.out.println(noSpaces);  // "HelloWorld"
+```
+
+### Trimming Whitespace
+
+```java
+String messy = "  Hello World  ";
+String clean = messy.trim();
+System.out.println(clean);  // "Hello World" (no spaces at ends)
+```
+
+### Splitting Strings
+
+```java
+String command = "give player sword 5";
+String[] parts = command.split(" ");
+
+System.out.println(parts[0]);  // "give"
+System.out.println(parts[1]);  // "player"
+System.out.println(parts[2]);  // "sword"
+System.out.println(parts[3]);  // "5"
+```
+
+## String Comparison
+
+<Callout type="warning" title="Never Use == for Strings">
+  Always use `.equals()` to compare string contents!
+
+  ```java
+  String name1 = "Steve";
+  String name2 = "Steve";
+
+  // Wrong - Compares object references
+  if (name1 == name2) {
+      System.out.println("Same");
+  }
+
+  // Correct - Compares actual text
+  if (name1.equals(name2)) {
+      System.out.println("Same");
+  }
+
+  // Ignore case when comparing
+  if (name1.equalsIgnoreCase("steve")) {
+      System.out.println("Same (ignoring case)");
+  }
+  ```
+</Callout>
+
+### Comparing Order
+
+```java
+String a = "Apple";
+String b = "Banana";
+
+int result = a.compareTo(b);
+// result < 0 if a comes before b
+// result == 0 if a equals b
+// result > 0 if a comes after b
+
+if (a.compareTo(b) < 0) {
+    System.out.println(a + " comes before " + b);
+}
+```
+
+## String Concatenation
+
+### Using + Operator
+
+```java
+String first = "Hello";
+String second = "World";
+String combined = first + " " + second;  // "Hello World"
+
+int score = 100;
+String message = "Score: " + score;  // "Score: 100"
+```
+
+### Using concat()
+
+```java
+String result = "Hello".concat(" World");  // "Hello World"
+```
+
+### Building Long Strings
+
+For many concatenations, use `StringBuilder`:
+
+```java
+StringBuilder builder = new StringBuilder();
+builder.append("Player: ");
+builder.append("Alice");
+builder.append(", Level: ");
+builder.append(10);
+builder.append(", Health: ");
+builder.append(100);
+
+String result = builder.toString();
+System.out.println(result);
+// "Player: Alice, Level: 10, Health: 100"
+```
+
+<Callout type="info" title="Why StringBuilder?">
+  Regular concatenation creates many temporary strings:
+
+  ```java
+  // Inefficient - Creates many temporary strings
+  String result = "";
+  for (int i = 0; i < 1000; i++) {
+      result = result + i;  // Creates 1000 temporary strings!
+  }
+
+  // Efficient - StringBuilder is mutable
+  StringBuilder sb = new StringBuilder();
+  for (int i = 0; i < 1000; i++) {
+      sb.append(i);  // Modifies one object
+  }
+  String result = sb.toString();
+  ```
+
+  Use `StringBuilder` when building strings in loops!
+</Callout>
+
+## Practical Examples
+
+### Parse Player Command
+
+```java
+public class CommandParser {
+    public static void parseCommand(String command) {
+        // "/give Steve diamond_sword 1"
+        String[] parts = command.split(" ");
+        
+        String action = parts[0].replace("/", "");  // "give"
+        String player = parts[1];                   // "Steve"
+        String item = parts[2];                     // "diamond_sword"
+        int amount = Integer.parseInt(parts[3]);    // 1
+        
+        System.out.println("Action: " + action);
+        System.out.println("Player: " + player);
+        System.out.println("Item: " + item);
+        System.out.println("Amount: " + amount);
+    }
+    
+    public static void main(String[] args) {
+        parseCommand("/give Steve diamond_sword 1");
+    }
+}
+```
+
+### Format Player Display Name
+
+```java
+public class PlayerFormatter {
+    public static String formatName(String name, int level, String rank) {
+        StringBuilder formatted = new StringBuilder();
+        
+        if (rank != null && !rank.isEmpty()) {
+            formatted.append("[").append(rank).append("] ");
+        }
+        
+        formatted.append(name);
+        formatted.append(" (Lv. ").append(level).append(")");
+        
+        return formatted.toString();
+    }
+    
+    public static void main(String[] args) {
+        String display1 = formatName("Alice", 10, "VIP");
+        System.out.println(display1);  // "[VIP] Alice (Lv. 10)"
+        
+        String display2 = formatName("Bob", 5, null);
+        System.out.println(display2);  // "Bob (Lv. 5)"
+    }
+}
+```
+
+### Validate Username
+
+```java
+public class UsernameValidator {
+    public static boolean isValid(String username) {
+        // Rules: 3-16 characters, letters and numbers only
+        
+        if (username == null || username.isEmpty()) {
+            return false;
+        }
+        
+        username = username.trim();
+        
+        if (username.length() < 3 || username.length() > 16) {
+            return false;
+        }
+        
+        for (int i = 0; i < username.length(); i++) {
+            char c = username.charAt(i);
+            if (!Character.isLetterOrDigit(c)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+    
+    public static void main(String[] args) {
+        System.out.println(isValid("Steve"));      // true
+        System.out.println(isValid("Player_123")); // false (has underscore)
+        System.out.println(isValid("ab"));         // false (too short)
+        System.out.println(isValid(""));           // false (empty)
+    }
+}
+```
+
+### Item Description Builder
+
+```java
+public class ItemDescription {
+    public static String buildDescription(String name, String rarity, 
+                                         int damage, int durability) {
+        StringBuilder desc = new StringBuilder();
+        
+        // Title with rarity color code
+        desc.append(getRarityColor(rarity));
+        desc.append(name);
+        desc.append("\n");
+        
+        // Stats
+        desc.append("Damage: ").append(damage).append("\n");
+        desc.append("Durability: ").append(durability).append("/");
+        desc.append(durability).append("\n");
+        desc.append("Rarity: ").append(rarity);
+        
+        return desc.toString();
+    }
+    
+    private static String getRarityColor(String rarity) {
+        switch (rarity.toLowerCase()) {
+            case "legendary": return "§6";  // Gold
+            case "epic": return "§5";       // Purple
+            case "rare": return "§9";       // Blue
+            case "common": return "§f";     // White
+            default: return "§7";           // Gray
+        }
+    }
+    
+    public static void main(String[] args) {
+        String desc = buildDescription("Excalibur", "Legendary", 50, 1000);
+        System.out.println(desc);
+    }
+}
+```
+
+### Chat Message Filter
+
+```java
+public class ChatFilter {
+    private static String[] bannedWords = {"badword1", "badword2"};
+    
+    public static String filterMessage(String message) {
+        String filtered = message.toLowerCase();
+        
+        for (String word : bannedWords) {
+            if (filtered.contains(word)) {
+                String replacement = "*".repeat(word.length());
+                filtered = filtered.replace(word, replacement);
+            }
+        }
+        
+        return filtered;
+    }
+    
+    public static void main(String[] args) {
+        String message = "This is a badword1 test";
+        String clean = filterMessage(message);
+        System.out.println(clean);  // "this is a ******** test"
+    }
+}
+```
+
+## String Formatting
+
+### Using String.format()
+
+```java
+String name = "Alice";
+int level = 10;
+double health = 85.5;
+
+String formatted = String.format("%s is level %d with %.1f%% health", 
+                                 name, level, health);
+System.out.println(formatted);
+// "Alice is level 10 with 85.5% health"
+```
+
+<Callout type="info" title="Format Specifiers">
+  Common format codes:
+
+  - `%s` - String
+  - `%d` - Integer
+  - `%f` - Floating point
+  - `%.2f` - Float with 2 decimal places
+  - `%n` - New line (platform independent)
+
+  ```java
+  String.format("Name: %s", "Steve");          // "Name: Steve"
+  String.format("Level: %d", 10);              // "Level: 10"
+  String.format("Health: %.1f", 85.5);         // "Health: 85.5"
+  String.format("Position: (%d, %d, %d)", 
+                10, 64, -5);                    // "Position: (10, 64, -5)"
+  ```
+</Callout>
+
+## Common String Operations
+
+### Check if String is Empty
+
+```java
+String text = "";
+
+// Check for empty or null
+if (text == null || text.isEmpty()) {
+    System.out.println("Empty!");
+}
+
+// Check for empty, null, or whitespace only
+if (text == null || text.trim().isEmpty()) {
+    System.out.println("Empty or whitespace!");
+}
+```
+
+### Count Occurrences
+
+```java
+public static int countOccurrences(String text, String target) {
+    int count = 0;
+    int index = 0;
+    
+    while ((index = text.indexOf(target, index)) != -1) {
+        count++;
+        index += target.length();
+    }
+    
+    return count;
+}
+
+// Usage
+int count = countOccurrences("hello hello world", "hello");
+System.out.println(count);  // 2
+```
+
+### Reverse a String
+
+```java
+public static String reverse(String text) {
+    StringBuilder sb = new StringBuilder(text);
+    return sb.reverse().toString();
+}
+
+// Usage
+String reversed = reverse("Hello");
+System.out.println(reversed);  // "olleH"
+```
+
+### Check if Palindrome
+
+```java
+public static boolean isPalindrome(String text) {
+    String cleaned = text.toLowerCase().replaceAll("[^a-z0-9]", "");
+    String reversed = new StringBuilder(cleaned).reverse().toString();
+    return cleaned.equals(reversed);
+}
+
+// Usage
+System.out.println(isPalindrome("racecar"));     // true
+System.out.println(isPalindrome("hello"));       // false
+```
+
+## Practice Exercises
+
+1. **Username Checker**: Write a method that checks if a username:
+   - Is between 3 and 16 characters
+   - Contains only letters, numbers, and underscores
+   - Doesn't start with a number
+   - Returns true if valid, false otherwise
+
+2. **Command Parser**: Parse this command format: `/teleport x y z`
+   - Extract the coordinates
+   - Convert them to integers
+   - Return an array of the three values
+
+3. **Chat Formatter**: Create a method that formats chat messages:
+   - Input: player name, rank, message
+   - Output: `"[RANK] PlayerName: message"`
+   - If no rank, just show `"PlayerName: message"`
+
+4. **Word Counter**: Count how many words are in a sentence (words are separated by spaces)
+
+5. **Title Case**: Convert a string to title case:
+   - Input: `"hello world"`
+   - Output: `"Hello World"`
diff --git a/content/docs/pt-PT/guides/java-basics/10-arraylist.mdx b/content/docs/pt-PT/guides/java-basics/10-arraylist.mdx
new file mode 100644
index 00000000..343ae5d5
--- /dev/null
+++ b/content/docs/pt-PT/guides/java-basics/10-arraylist.mdx
@@ -0,0 +1,530 @@
+---
+title: 10 - ArrayList and Collections
+description: Learn to use flexible, resizable collections in Java.
+---
+
+Arrays have a fixed size, but what if you need to add or remove elements? That's where `ArrayList` comes in - a resizable collection that grows and shrinks automatically.
+
+## ArrayList Basics
+
+```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]
+    }
+}
+```
+
+<Callout type="info" title="ArrayList vs Array">
+  | **Array**                               | **ArrayList**                                         |
+  | --------------------------------------- | ----------------------------------------------------- |
+  | Fixed size                              | Resizable (grows/shrinks)                             |
+  | Can hold primitives (int, double, etc.) | Can only hold objects (Integer, Double, String, etc.) |
+  | Faster access                           | More features (add, remove, etc.)                     |
+  | `int[] numbers = new int[10];`          | `ArrayList<Integer> numbers = new ArrayList<>();`     |
+</Callout>
+
+## Creating ArrayLists
+
+```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<>();
+```
+
+<Callout type="warning" title="Primitives in ArrayList">
+  You can't use primitives directly. Use their wrapper classes:
+
+  ```java
+  // Wrong
+  ArrayList<int> numbers = new ArrayList<>();
+
+  // Correct - Use wrapper class
+  ArrayList<Integer> numbers = new ArrayList<>();
+  ```
+
+  Wrapper classes:
+
+  - `int` → `Integer`
+  - `double` → `Double`
+  - `boolean` → `Boolean`
+  - `char` → `Character`
+</Callout>
+
+## Common ArrayList Methods
+
+### Adding Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+
+items.add("Sword");           // Add to end
+items.add("Shield");
+items.add(0, "Helmet");       // Add at specific index
+
+System.out.println(items);    // [Helmet, Sword, Shield]
+```
+
+### Accessing Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+String first = items.get(0);    // "Sword"
+String second = items.get(1);   // "Shield"
+
+int size = items.size();        // 2
+```
+
+### Removing Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+items.add("Potion");
+
+items.remove(1);               // Remove by index (Shield)
+items.remove("Potion");        // Remove by value
+
+System.out.println(items);     // [Sword]
+```
+
+### Checking Contents
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+boolean hasSword = items.contains("Sword");     // true
+boolean hasAxe = items.contains("Axe");         // false
+
+boolean isEmpty = items.isEmpty();              // false
+int size = items.size();                        // 2
+```
+
+### Modifying Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Wooden Sword");
+
+items.set(0, "Iron Sword");    // Replace at index 0
+
+System.out.println(items);     // [Iron Sword]
+```
+
+### Clearing All Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+items.clear();                 // Remove everything
+System.out.println(items);     // []
+```
+
+## Looping Through ArrayList
+
+### Using For Loop
+
+```java
+ArrayList<String> players = new ArrayList<>();
+players.add("Alice");
+players.add("Bob");
+players.add("Charlie");
+
+for (int i = 0; i < players.size(); i++) {
+    System.out.println(players.get(i));
+}
+```
+
+### Using Enhanced For Loop
+
+```java
+for (String player : players) {
+    System.out.println(player);
+}
+```
+
+### Using forEach (Java 8+)
+
+```java
+players.forEach(player -> System.out.println(player));
+```
+
+## Practical Examples
+
+### Player Inventory System
+
+```java
+import java.util.ArrayList;
+
+public class Inventory {
+    private ArrayList<String> items;
+    private int maxSize;
+    
+    public Inventory(int maxSize) {
+        this.items = new ArrayList<>();
+        this.maxSize = maxSize;
+    }
+    
+    public boolean addItem(String item) {
+        if (items.size() >= maxSize) {
+            System.out.println("Inventory full!");
+            return false;
+        }
+        
+        items.add(item);
+        System.out.println("Added: " + item);
+        return true;
+    }
+    
+    public boolean removeItem(String item) {
+        if (items.remove(item)) {
+            System.out.println("Removed: " + item);
+            return true;
+        }
+        
+        System.out.println("Item not found!");
+        return false;
+    }
+    
+    public void displayInventory() {
+        System.out.println("=== Inventory (" + items.size() + "/" + maxSize + ") ===");
+        for (int i = 0; i < items.size(); i++) {
+            System.out.println((i + 1) + ". " + items.get(i));
+        }
+    }
+    
+    public int getItemCount() {
+        return items.size();
+    }
+    
+    public boolean isFull() {
+        return items.size() >= maxSize;
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        Inventory inv = new Inventory(5);
+        
+        inv.addItem("Sword");
+        inv.addItem("Shield");
+        inv.addItem("Potion");
+        inv.displayInventory();
+        
+        inv.removeItem("Shield");
+        inv.displayInventory();
+    }
+}
+```
+
+### Quest System
+
+```java
+import java.util.ArrayList;
+
+public class QuestManager {
+    private ArrayList<String> activeQuests;
+    private ArrayList<String> completedQuests;
+    
+    public QuestManager() {
+        this.activeQuests = new ArrayList<>();
+        this.completedQuests = new ArrayList<>();
+    }
+    
+    public void startQuest(String questName) {
+        if (!activeQuests.contains(questName)) {
+            activeQuests.add(questName);
+            System.out.println("Quest started: " + questName);
+        } else {
+            System.out.println("Quest already active!");
+        }
+    }
+    
+    public void completeQuest(String questName) {
+        if (activeQuests.remove(questName)) {
+            completedQuests.add(questName);
+            System.out.println("Quest completed: " + questName);
+        } else {
+            System.out.println("Quest not found in active quests!");
+        }
+    }
+    
+    public void displayQuests() {
+        System.out.println("\n=== Active Quests ===");
+        if (activeQuests.isEmpty()) {
+            System.out.println("No active quests");
+        } else {
+            for (String quest : activeQuests) {
+                System.out.println("- " + quest);
+            }
+        }
+        
+        System.out.println("\n=== Completed Quests ===");
+        if (completedQuests.isEmpty()) {
+            System.out.println("No completed quests");
+        } else {
+            for (String quest : completedQuests) {
+                System.out.println("" + quest);
+            }
+        }
+    }
+    
+    public int getTotalCompleted() {
+        return completedQuests.size();
+    }
+}
+```
+
+### Leaderboard System
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class Leaderboard {
+    private ArrayList<Integer> scores;
+    private ArrayList<String> players;
+    
+    public Leaderboard() {
+        this.scores = new ArrayList<>();
+        this.players = new ArrayList<>();
+    }
+    
+    public void addScore(String player, int score) {
+        players.add(player);
+        scores.add(score);
+        System.out.println(player + " scored " + score + " points!");
+    }
+    
+    public void displayTop(int count) {
+        System.out.println("\n=== Top " + count + " Players ===");
+        
+        // Create copies to sort
+        ArrayList<Integer> sortedScores = new ArrayList<>(scores);
+        ArrayList<String> sortedPlayers = new ArrayList<>(players);
+        
+        // Bubble sort (simple for learning)
+        for (int i = 0; i < sortedScores.size() - 1; i++) {
+            for (int j = 0; j < sortedScores.size() - i - 1; j++) {
+                if (sortedScores.get(j) < sortedScores.get(j + 1)) {
+                    // Swap scores
+                    int tempScore = sortedScores.get(j);
+                    sortedScores.set(j, sortedScores.get(j + 1));
+                    sortedScores.set(j + 1, tempScore);
+                    
+                    // Swap players
+                    String tempPlayer = sortedPlayers.get(j);
+                    sortedPlayers.set(j, sortedPlayers.get(j + 1));
+                    sortedPlayers.set(j + 1, tempPlayer);
+                }
+            }
+        }
+        
+        // Display top scores
+        int limit = Math.min(count, sortedScores.size());
+        for (int i = 0; i < limit; i++) {
+            System.out.println((i + 1) + ". " + sortedPlayers.get(i) + 
+                             " - " + sortedScores.get(i) + " points");
+        }
+    }
+}
+```
+
+### Online Players Tracker
+
+```java
+import java.util.ArrayList;
+
+public class OnlinePlayersTracker {
+    private ArrayList<String> onlinePlayers;
+    
+    public OnlinePlayersTracker() {
+        this.onlinePlayers = new ArrayList<>();
+    }
+    
+    public void playerJoin(String playerName) {
+        if (!onlinePlayers.contains(playerName)) {
+            onlinePlayers.add(playerName);
+            broadcast(playerName + " joined the game");
+            updatePlayerCount();
+        }
+    }
+    
+    public void playerLeave(String playerName) {
+        if (onlinePlayers.remove(playerName)) {
+            broadcast(playerName + " left the game");
+            updatePlayerCount();
+        }
+    }
+    
+    public boolean isOnline(String playerName) {
+        return onlinePlayers.contains(playerName);
+    }
+    
+    public int getPlayerCount() {
+        return onlinePlayers.size();
+    }
+    
+    public void listPlayers() {
+        System.out.println("\n=== Online Players (" + getPlayerCount() + ") ===");
+        for (String player : onlinePlayers) {
+            System.out.println("• " + player);
+        }
+    }
+    
+    private void broadcast(String message) {
+        System.out.println("[Server] " + message);
+    }
+    
+    private void updatePlayerCount() {
+        System.out.println("Players online: " + getPlayerCount());
+    }
+}
+```
+
+## ArrayList of Custom Objects
+
+You can store your own classes in ArrayLists:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    
+    public Player(String name, int level) {
+        this.name = name;
+        this.level = level;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public int getLevel() {
+        return level;
+    }
+    
+    @Override
+    public String toString() {
+        return name + " (Lv. " + level + ")";
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        ArrayList<Player> players = new ArrayList<>();
+        
+        players.add(new Player("Alice", 10));
+        players.add(new Player("Bob", 15));
+        players.add(new Player("Charlie", 8));
+        
+        // Display all players
+        for (Player player : players) {
+            System.out.println(player);
+        }
+        
+        // Find player by name
+        for (Player player : players) {
+            if (player.getName().equals("Bob")) {
+                System.out.println("Found: " + player);
+            }
+        }
+    }
+}
+```
+
+## Useful ArrayList Operations
+
+### Convert to Array
+
+```java
+ArrayList<String> list = new ArrayList<>();
+list.add("A");
+list.add("B");
+
+String[] array = list.toArray(new String[0]);
+```
+
+### Convert Array to ArrayList
+
+```java
+String[] array = {"A", "B", "C"};
+ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
+```
+
+### Copy an ArrayList
+
+```java
+ArrayList<String> original = new ArrayList<>();
+original.add("A");
+original.add("B");
+
+// Shallow copy
+ArrayList<String> copy = new ArrayList<>(original);
+```
+
+### Find Index of Element
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+int index = items.indexOf("Shield");  // 1
+int notFound = items.indexOf("Axe");  // -1
+```
+
+## Practice Exercises
+
+1. **Shopping Cart**: Create a shopping cart system:
+   - Add items
+   - Remove items
+   - Calculate total items
+   - Clear cart
+
+2. **Friend List**: Create a friend management system:
+   - Add friend
+   - Remove friend
+   - Check if someone is a friend
+   - Display all friends
+
+3. **Todo List**: Build a todo list:
+   - Add task
+   - Mark task as complete (move to completed list)
+   - Display active tasks
+   - Display completed tasks
+
+4. **High Scores**: Create a high score system:
+   - Add scores
+   - Display top 5 scores in order
+   - Remove lowest score if more than 10 scores exist
+
+---
diff --git a/content/docs/pt-PT/guides/java-basics/11-hashmaps.mdx b/content/docs/pt-PT/guides/java-basics/11-hashmaps.mdx
new file mode 100644
index 00000000..a06511cf
--- /dev/null
+++ b/content/docs/pt-PT/guides/java-basics/11-hashmaps.mdx
@@ -0,0 +1,568 @@
+---
+title: 11 - HashMap and Key-Value Storage
+description: Learn to store and retrieve data using key-value pairs.
+---
+
+A `HashMap` stores data in key-value pairs, like a real-world dictionary. You look up a word (key) to find its definition (value). This is perfect for player data, item properties, and configuration settings.
+
+## HashMap Basics
+
+```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);
+    }
+}
+```
+
+<Callout type="info" title="HashMap vs ArrayList">
+  | **HashMap**                     | **ArrayList**                 |
+  | ------------------------------- | ----------------------------- |
+  | Unordered                       | Ordered by index (0, 1, 2...) |
+  | Access by key (can be any type) | Access by position            |
+  | Good for looking up values      | Good for lists of items       |
+  | Each key is unique              | Can have duplicates           |
+
+  ```java
+  // ArrayList - access by number
+  ArrayList<String> players = new ArrayList<>();
+  players.add("Alice");
+  String player = players.get(0);  // Get first player
+
+  // HashMap - access by name
+  HashMap<String, Integer> levels = new HashMap<>();
+  levels.put("Alice", 10);
+  int level = levels.get("Alice");  // Get Alice's level
+  ```
+</Callout>
+
+## Common HashMap Methods
+
+### Adding and Updating
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+
+scores.put("Alice", 100);     // Add new entry
+scores.put("Bob", 150);
+scores.put("Alice", 200);     // Update existing (Alice now 200)
+```
+
+### Getting Values
+
+```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)
+```
+
+### Checking for Keys/Values
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+boolean hasAlice = scores.containsKey("Alice");    // true
+boolean hasDave = scores.containsKey("Dave");      // false
+
+boolean has100 = scores.containsValue(100);        // true
+boolean has200 = scores.containsValue(200);        // false
+```
+
+### Removing Entries
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+scores.put("Bob", 150);
+
+scores.remove("Alice");           // Remove by key
+System.out.println(scores);       // {Bob=150}
+
+scores.clear();                   // Remove everything
+System.out.println(scores);       // {}
+```
+
+### Size and Empty Check
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+int size = scores.size();         // 1
+boolean empty = scores.isEmpty(); // false
+```
+
+## Looping Through HashMap
+
+### Loop Through Keys
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+scores.put("Bob", 150);
+scores.put("Charlie", 75);
+
+for (String name : scores.keySet()) {
+    System.out.println(name);
+}
+// Output: Alice, Bob, Charlie (order may vary)
+```
+
+### Loop Through Values
+
+```java
+for (Integer score : scores.values()) {
+    System.out.println(score);
+}
+// Output: 100, 150, 75 (order may vary)
+```
+
+### Loop Through Both Keys and Values
+
+```java
+for (String name : scores.keySet()) {
+    int score = scores.get(name);
+    System.out.println(name + ": " + score);
+}
+
+// Or using entrySet (more efficient)
+for (var entry : scores.entrySet()) {
+    String name = entry.getKey();
+    int score = entry.getValue();
+    System.out.println(name + ": " + score);
+}
+```
+
+<Callout type="info" title="HashMap Order">
+  HashMap does **not** maintain insertion order! If you need order, use `LinkedHashMap`:
+
+  ```java
+  import java.util.LinkedHashMap;
+
+  LinkedHashMap<String, Integer> orderedScores = new LinkedHashMap<>();
+  orderedScores.put("Alice", 100);
+  orderedScores.put("Bob", 150);
+  orderedScores.put("Charlie", 75);
+
+  // Will print in insertion order
+  for (String name : orderedScores.keySet()) {
+      System.out.println(name);
+  }
+  // Output: Alice, Bob, Charlie (guaranteed order)
+  ```
+</Callout>
+
+## Practical Examples
+
+### Player Statistics System
+
+```java
+import java.util.HashMap;
+
+public class PlayerStats {
+    private HashMap<String, Integer> stats;
+    
+    public PlayerStats() {
+        this.stats = new HashMap<>();
+        // Initialize default stats
+        stats.put("health", 100);
+        stats.put("mana", 50);
+        stats.put("strength", 10);
+        stats.put("defense", 5);
+        stats.put("speed", 8);
+    }
+    
+    public int getStat(String statName) {
+        return stats.getOrDefault(statName, 0);
+    }
+    
+    public void setStat(String statName, int value) {
+        stats.put(statName, value);
+    }
+    
+    public void modifyStat(String statName, int amount) {
+        int current = getStat(statName);
+        stats.put(statName, current + amount);
+    }
+    
+    public void displayStats() {
+        System.out.println("=== Player Stats ===");
+        for (var entry : stats.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        PlayerStats stats = new PlayerStats();
+        stats.displayStats();
+        
+        stats.modifyStat("strength", 5);
+        stats.modifyStat("health", -20);
+        
+        System.out.println("\nAfter modifications:");
+        stats.displayStats();
+    }
+}
+```
+
+### Item Properties Database
+
+```java
+import java.util.HashMap;
+
+public class ItemDatabase {
+    private HashMap<String, HashMap<String, Object>> items;
+    
+    public ItemDatabase() {
+        this.items = new HashMap<>();
+    }
+    
+    public void addItem(String itemName) {
+        HashMap<String, Object> properties = new HashMap<>();
+        properties.put("damage", 0);
+        properties.put("durability", 100);
+        properties.put("rarity", "Common");
+        properties.put("stackable", true);
+        
+        items.put(itemName, properties);
+    }
+    
+    public void setProperty(String itemName, String property, Object value) {
+        if (items.containsKey(itemName)) {
+            items.get(itemName).put(property, value);
+        }
+    }
+    
+    public Object getProperty(String itemName, String property) {
+        if (items.containsKey(itemName)) {
+            return items.get(itemName).get(property);
+        }
+        return null;
+    }
+    
+    public void displayItem(String itemName) {
+        if (!items.containsKey(itemName)) {
+            System.out.println("Item not found!");
+            return;
+        }
+        
+        System.out.println("=== " + itemName + " ===");
+        HashMap<String, Object> props = items.get(itemName);
+        for (var entry : props.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        ItemDatabase db = new ItemDatabase();
+        
+        db.addItem("Iron Sword");
+        db.setProperty("Iron Sword", "damage", 15);
+        db.setProperty("Iron Sword", "rarity", "Uncommon");
+        
+        db.displayItem("Iron Sword");
+    }
+}
+```
+
+### Configuration Manager
+
+```java
+import java.util.HashMap;
+
+public class GameConfig {
+    private HashMap<String, String> settings;
+    
+    public GameConfig() {
+        this.settings = new HashMap<>();
+        loadDefaults();
+    }
+    
+    private void loadDefaults() {
+        settings.put("difficulty", "normal");
+        settings.put("musicVolume", "50");
+        settings.put("sfxVolume", "50");
+        settings.put("renderDistance", "10");
+        settings.put("showFPS", "false");
+    }
+    
+    public String getSetting(String key) {
+        return settings.getOrDefault(key, "");
+    }
+    
+    public void setSetting(String key, String value) {
+        settings.put(key, value);
+        System.out.println("Set " + key + " to " + value);
+    }
+    
+    public int getIntSetting(String key) {
+        String value = getSetting(key);
+        try {
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            return 0;
+        }
+    }
+    
+    public boolean getBooleanSetting(String key) {
+        return "true".equalsIgnoreCase(getSetting(key));
+    }
+    
+    public void displaySettings() {
+        System.out.println("=== Game Settings ===");
+        for (var entry : settings.entrySet()) {
+            System.out.println(entry.getKey() + " = " + entry.getValue());
+        }
+    }
+}
+```
+
+### Player Inventory with Quantities
+
+```java
+import java.util.HashMap;
+
+public class Inventory {
+    private HashMap<String, Integer> items;
+    private int maxSlots;
+    
+    public Inventory(int maxSlots) {
+        this.items = new HashMap<>();
+        this.maxSlots = maxSlots;
+    }
+    
+    public boolean addItem(String itemName, int quantity) {
+        if (items.size() >= maxSlots && !items.containsKey(itemName)) {
+            System.out.println("Inventory full!");
+            return false;
+        }
+        
+        int current = items.getOrDefault(itemName, 0);
+        items.put(itemName, current + quantity);
+        System.out.println("Added " + quantity + "x " + itemName);
+        return true;
+    }
+    
+    public boolean removeItem(String itemName, int quantity) {
+        if (!items.containsKey(itemName)) {
+            System.out.println("Don't have that item!");
+            return false;
+        }
+        
+        int current = items.get(itemName);
+        if (current < quantity) {
+            System.out.println("Not enough " + itemName);
+            return false;
+        }
+        
+        if (current == quantity) {
+            items.remove(itemName);
+        } else {
+            items.put(itemName, current - quantity);
+        }
+        
+        System.out.println("Removed " + quantity + "x " + itemName);
+        return true;
+    }
+    
+    public int getQuantity(String itemName) {
+        return items.getOrDefault(itemName, 0);
+    }
+    
+    public boolean hasItem(String itemName) {
+        return items.containsKey(itemName);
+    }
+    
+    public void displayInventory() {
+        System.out.println("\n=== Inventory (" + items.size() + "/" + maxSlots + " slots) ===");
+        if (items.isEmpty()) {
+            System.out.println("Empty");
+        } else {
+            for (var entry : items.entrySet()) {
+                System.out.println(entry.getKey() + " x" + entry.getValue());
+            }
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        Inventory inv = new Inventory(10);
+        
+        inv.addItem("Wood", 64);
+        inv.addItem("Stone", 32);
+        inv.addItem("Wood", 20);  // Adds to existing
+        
+        inv.displayInventory();
+        
+        inv.removeItem("Wood", 50);
+        inv.displayInventory();
+    }
+}
+```
+
+### Cooldown Manager
+
+```java
+import java.util.HashMap;
+
+public class CooldownManager {
+    private HashMap<String, Long> cooldowns;
+    
+    public CooldownManager() {
+        this.cooldowns = new HashMap<>();
+    }
+    
+    public void startCooldown(String ability, long durationMs) {
+        long endTime = System.currentTimeMillis() + durationMs;
+        cooldowns.put(ability, endTime);
+        System.out.println(ability + " on cooldown for " + (durationMs / 1000) + " seconds");
+    }
+    
+    public boolean isOnCooldown(String ability) {
+        if (!cooldowns.containsKey(ability)) {
+            return false;
+        }
+        
+        long endTime = cooldowns.get(ability);
+        long now = System.currentTimeMillis();
+        
+        if (now >= endTime) {
+            cooldowns.remove(ability);
+            return false;
+        }
+        
+        return true;
+    }
+    
+    public long getRemainingTime(String ability) {
+        if (!isOnCooldown(ability)) {
+            return 0;
+        }
+        
+        long endTime = cooldowns.get(ability);
+        long now = System.currentTimeMillis();
+        return (endTime - now) / 1000;  // Return seconds
+    }
+    
+    public boolean useAbility(String ability, long cooldownSeconds) {
+        if (isOnCooldown(ability)) {
+            long remaining = getRemainingTime(ability);
+            System.out.println(ability + " is on cooldown (" + remaining + "s remaining)");
+            return false;
+        }
+        
+        System.out.println("Used " + ability + "!");
+        startCooldown(ability, cooldownSeconds * 1000);
+        return true;
+    }
+}
+```
+
+## HashMap with Custom Objects
+
+Store your own classes as values:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    private int health;
+    
+    public Player(String name, int level) {
+        this.name = name;
+        this.level = level;
+        this.health = 100;
+    }
+    
+    // Getters and setters...
+    
+    @Override
+    public String toString() {
+        return name + " (Lv. " + level + ", HP: " + health + ")";
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        HashMap<String, Player> players = new HashMap<>();
+        
+        players.put("player1", new Player("Alice", 10));
+        players.put("player2", new Player("Bob", 15));
+        
+        // Get and use player
+        Player alice = players.get("player1");
+        System.out.println(alice);
+    }
+}
+```
+
+## Nested HashMaps
+
+HashMaps can contain other HashMaps:
+
+```java
+// Store multiple properties per player
+HashMap<String, HashMap<String, Integer>> playerData = new HashMap<>();
+
+// Add player with stats
+HashMap<String, Integer> aliceStats = new HashMap<>();
+aliceStats.put("level", 10);
+aliceStats.put("health", 100);
+aliceStats.put("mana", 50);
+playerData.put("Alice", aliceStats);
+
+// Access nested data
+int aliceLevel = playerData.get("Alice").get("level");
+System.out.println("Alice's level: " + aliceLevel);
+```
+
+## Practice Exercises
+
+1. **Phone Book**: Create a phone book that stores names and phone numbers. Add methods to:
+   - Add contact
+   - Find number by name
+   - Delete contact
+   - Display all contacts
+
+2. **Grade Manager**: Store student names and grades. Create methods to:
+   - Add student with grade
+   - Update grade
+   - Calculate class average
+   - Find highest grade
+
+3. **Word Counter**: Write a program that counts how many times each word appears in a sentence using a HashMap.
+
+4. **Item Shop**: Create a shop where items have names and prices. Add methods to:
+   - Add item with price
+   - Get item price
+   - Apply discount to all items
+   - Display all items and prices
+
+---
diff --git a/content/docs/pt-PT/guides/java-basics/12-exception-handling.mdx b/content/docs/pt-PT/guides/java-basics/12-exception-handling.mdx
new file mode 100644
index 00000000..a43155d0
--- /dev/null
+++ b/content/docs/pt-PT/guides/java-basics/12-exception-handling.mdx
@@ -0,0 +1,504 @@
+---
+title: 12 - Exception Handling
+description: Learn how to handle errors gracefully in your Java programs.
+---
+
+Exceptions are errors that occur while your program is running. Instead of crashing, you can "catch" these errors and handle them gracefully.
+
+## What is an Exception?
+
+An exception is an event that disrupts the normal flow of your program:
+
+```java
+String text = null;
+System.out.println(text.length());  // NullPointerException - crashes!
+```
+
+Without handling, this crashes your mod and breaks the game!
+
+## Try-Catch Blocks
+
+Use `try-catch` to handle exceptions:
+
+```java
+try {
+    // Code that might throw an exception
+    String text = null;
+    System.out.println(text.length());
+} catch (NullPointerException e) {
+    // Code to handle the error
+    System.out.println("Error: text was null!");
+}
+
+System.out.println("Program continues...");
+```
+
+<Callout type="info" title="How Try-Catch Works">
+  1. Code in `try` block runs normally
+  2. If an exception occurs, execution jumps to `catch` block
+  3. After `catch` block, program continues normally
+  4. If no exception occurs, `catch` block is skipped
+
+  ```java
+  try {
+      // Try to do something risky
+      int result = 10 / 0;  // Division by zero!
+  } catch (ArithmeticException e) {
+      // Handle the error
+      System.out.println("Can't divide by zero!");
+  }
+  // Program keeps running
+  ```
+</Callout>
+
+## Common Exception Types
+
+### NullPointerException
+
+Accessing methods/properties on null objects:
+
+```java
+String name = null;
+
+try {
+    int length = name.length();
+} catch (NullPointerException e) {
+    System.out.println("Name is null!");
+}
+```
+
+### ArrayIndexOutOfBoundsException
+
+Accessing invalid array index:
+
+```java
+int[] numbers = {1, 2, 3};
+
+try {
+    int value = numbers[10];  // Index 10 doesn't exist!
+} catch (ArrayIndexOutOfBoundsException e) {
+    System.out.println("Invalid array index!");
+}
+```
+
+### NumberFormatException
+
+Converting invalid strings to numbers:
+
+```java
+try {
+    int number = Integer.parseInt("abc");  // Not a number!
+} catch (NumberFormatException e) {
+    System.out.println("Invalid number format!");
+}
+```
+
+### ArithmeticException
+
+Math errors like division by zero:
+
+```java
+try {
+    int result = 10 / 0;
+} catch (ArithmeticException e) {
+    System.out.println("Math error!");
+}
+```
+
+## Multiple Catch Blocks
+
+Handle different exceptions differently:
+
+```java
+String input = "abc";
+
+try {
+    int number = Integer.parseInt(input);
+    int result = 100 / number;
+    System.out.println(result);
+} catch (NumberFormatException e) {
+    System.out.println("Invalid number!");
+} catch (ArithmeticException e) {
+    System.out.println("Cannot divide by zero!");
+}
+```
+
+## Catching Multiple Exception Types
+
+Catch multiple exceptions in one block:
+
+```java
+try {
+    // Some risky code
+} catch (NumberFormatException | ArithmeticException e) {
+    System.out.println("Math-related error occurred!");
+}
+```
+
+## The Finally Block
+
+Code that **always** runs, whether exception occurs or not:
+
+```java
+try {
+    System.out.println("Opening file...");
+    // Code that might fail
+} catch (Exception e) {
+    System.out.println("Error: " + e.getMessage());
+} finally {
+    System.out.println("Closing file...");
+    // This ALWAYS runs - good for cleanup
+}
+```
+
+<Callout type="info" title="When to Use Finally">
+  Use `finally` for cleanup tasks that must always happen:
+
+  - Closing files
+  - Releasing resources
+  - Saving data
+  - Logging
+
+  ```java
+  FileReader file = null;
+  try {
+      file = new FileReader("data.txt");
+      // Read file
+  } catch (Exception e) {
+      System.out.println("Error reading file");
+  } finally {
+      if (file != null) {
+          file.close();  // Always close the file!
+      }
+  }
+  ```
+</Callout>
+
+## Getting Exception Information
+
+The exception object contains useful information:
+
+```java
+try {
+    int result = Integer.parseInt("xyz");
+} catch (NumberFormatException e) {
+    System.out.println("Message: " + e.getMessage());
+    System.out.println("Type: " + e.getClass().getName());
+    e.printStackTrace();  // Print full error details
+}
+```
+
+## Practical Examples
+
+### Safe Player Input
+
+```java
+import java.util.Scanner;
+
+public class PlayerInput {
+    public static int getPlayerChoice(Scanner scanner) {
+        while (true) {
+            try {
+                System.out.print("Enter choice (1-5): ");
+                String input = scanner.nextLine();
+                int choice = Integer.parseInt(input);
+                
+                if (choice < 1 || choice > 5) {
+                    System.out.println("Please enter a number between 1 and 5");
+                    continue;
+                }
+                
+                return choice;
+            } catch (NumberFormatException e) {
+                System.out.println("Invalid input! Please enter a number.");
+            }
+        }
+    }
+    
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int choice = getPlayerChoice(scanner);
+        System.out.println("You chose: " + choice);
+    }
+}
+```
+
+### Safe Item Durability Update
+
+```java
+public class Item {
+    private String name;
+    private int durability;
+    private int maxDurability;
+    
+    public Item(String name, int maxDurability) {
+        this.name = name;
+        this.durability = maxDurability;
+        this.maxDurability = maxDurability;
+    }
+    
+    public void damage(int amount) {
+        try {
+            if (amount < 0) {
+                throw new IllegalArgumentException("Damage cannot be negative!");
+            }
+            
+            durability -= amount;
+            
+            if (durability < 0) {
+                durability = 0;
+            }
+            
+            System.out.println(name + " durability: " + durability + "/" + maxDurability);
+            
+            if (durability == 0) {
+                System.out.println(name + " broke!");
+            }
+        } catch (IllegalArgumentException e) {
+            System.out.println("Error: " + e.getMessage());
+        }
+    }
+}
+```
+
+### Safe Config Loading
+
+```java
+import java.util.HashMap;
+
+public class ConfigLoader {
+    private HashMap<String, String> settings;
+    
+    public ConfigLoader() {
+        this.settings = new HashMap<>();
+        loadDefaults();
+    }
+    
+    private void loadDefaults() {
+        settings.put("maxPlayers", "10");
+        settings.put("difficulty", "normal");
+        settings.put("pvpEnabled", "true");
+    }
+    
+    public int getIntSetting(String key, int defaultValue) {
+        try {
+            String value = settings.get(key);
+            if (value == null) {
+                return defaultValue;
+            }
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            System.out.println("Invalid number for " + key + ", using default");
+            return defaultValue;
+        }
+    }
+    
+    public boolean getBooleanSetting(String key, boolean defaultValue) {
+        try {
+            String value = settings.get(key);
+            if (value == null) {
+                return defaultValue;
+            }
+            return Boolean.parseBoolean(value);
+        } catch (Exception e) {
+            System.out.println("Invalid boolean for " + key + ", using default");
+            return defaultValue;
+        }
+    }
+    
+    public void setSetting(String key, String value) {
+        if (key == null || value == null) {
+            System.out.println("Key and value cannot be null!");
+            return;
+        }
+        settings.put(key, value);
+    }
+}
+```
+
+### Safe Array Access
+
+```java
+public class Inventory {
+    private String[] items;
+    
+    public Inventory(int size) {
+        this.items = new String[size];
+    }
+    
+    public boolean setItem(int slot, String item) {
+        try {
+            if (slot < 0 || slot >= items.length) {
+                throw new ArrayIndexOutOfBoundsException("Invalid slot: " + slot);
+            }
+            
+            items[slot] = item;
+            System.out.println("Placed " + item + " in slot " + slot);
+            return true;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Error: " + e.getMessage());
+            return false;
+        }
+    }
+    
+    public String getItem(int slot) {
+        try {
+            return items[slot];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Invalid slot: " + slot);
+            return null;
+        }
+    }
+}
+```
+
+### Command Parser with Error Handling
+
+```java
+public class CommandParser {
+    public static void parseCommand(String command) {
+        try {
+            if (command == null || command.trim().isEmpty()) {
+                throw new IllegalArgumentException("Command cannot be empty!");
+            }
+            
+            String[] parts = command.split(" ");
+            
+            if (parts.length < 2) {
+                throw new IllegalArgumentException("Invalid command format!");
+            }
+            
+            String action = parts[0];
+            String target = parts[1];
+            
+            switch (action) {
+                case "give":
+                    if (parts.length < 4) {
+                        throw new IllegalArgumentException("Usage: give <player> <item> <amount>");
+                    }
+                    String item = parts[2];
+                    int amount = Integer.parseInt(parts[3]);
+                    
+                    if (amount <= 0) {
+                        throw new IllegalArgumentException("Amount must be positive!");
+                    }
+                    
+                    System.out.println("Giving " + amount + " " + item + " to " + target);
+                    break;
+                    
+                case "tp":
+                    if (parts.length < 5) {
+                        throw new IllegalArgumentException("Usage: tp <player> <x> <y> <z>");
+                    }
+                    int x = Integer.parseInt(parts[2]);
+                    int y = Integer.parseInt(parts[3]);
+                    int z = Integer.parseInt(parts[4]);
+                    
+                    System.out.println("Teleporting " + target + " to " + x + ", " + y + ", " + z);
+                    break;
+                    
+                default:
+                    throw new IllegalArgumentException("Unknown command: " + action);
+            }
+        } catch (NumberFormatException e) {
+            System.out.println("Error: Invalid number in command!");
+        } catch (IllegalArgumentException e) {
+            System.out.println("Error: " + e.getMessage());
+        } catch (Exception e) {
+            System.out.println("Unexpected error: " + e.getMessage());
+        }
+    }
+    
+    public static void main(String[] args) {
+        parseCommand("give Steve diamond 5");
+        parseCommand("give Steve sword abc");  // Invalid number
+        parseCommand("tp Alice 10 64 20");
+        parseCommand("unknown command");       // Unknown command
+    }
+}
+```
+
+## Throwing Exceptions
+
+You can throw your own exceptions:
+
+```java
+public class Player {
+    private int health;
+    
+    public void setHealth(int health) {
+        if (health < 0) {
+            throw new IllegalArgumentException("Health cannot be negative!");
+        }
+        if (health > 100) {
+            throw new IllegalArgumentException("Health cannot exceed 100!");
+        }
+        this.health = health;
+    }
+}
+```
+
+<Callout type="info" title="When to Throw Exceptions">
+  Throw exceptions when:
+
+  - Method receives invalid input
+  - Operation cannot be completed
+  - Preconditions are not met
+  - Something unexpected happens
+
+  ```java
+  public void damagePlayer(int damage) {
+      if (damage < 0) {
+          throw new IllegalArgumentException("Damage must be positive!");
+      }
+      // Apply damage
+  }
+
+  public Item getItem(int slot) {
+      if (slot < 0 || slot >= inventory.length) {
+          throw new IndexOutOfBoundsException("Invalid inventory slot!");
+      }
+      return inventory[slot];
+  }
+  ```
+</Callout>
+
+## Checked vs Unchecked Exceptions
+
+<Callout type="warning" title="Exception Types">
+  **Unchecked Exceptions** (RuntimeException):
+
+  - Don't need to be caught
+  - Usually programming errors
+  - Examples: NullPointerException, ArrayIndexOutOfBoundsException
+
+  **Checked Exceptions**:
+
+  - Must be caught or declared
+  - Usually external errors (files, network)
+  - Examples: IOException, FileNotFoundException
+
+  ```java
+  // Unchecked - no need to catch
+  int result = 10 / 0;  // ArithmeticException
+
+  // Checked - must catch or declare
+  try {
+      FileReader file = new FileReader("data.txt");  // IOException
+  } catch (IOException e) {
+      // Handle error
+  }
+  ```
+</Callout>
+
+## Practice Exercises
+
+1. **Safe Division Calculator**: Create a method that divides two numbers. Handle division by zero and invalid input gracefully.
+
+2. **Player Level Setter**: Create a method that sets player level (1-100). Throw an exception if invalid, and handle it in main.
+
+3. **Safe Array Access**: Create a method that safely accesses array elements. Return null if index is invalid instead of crashing.
+
+4. **Config Parser**: Read a config string like "maxPlayers=10" and parse it. Handle invalid formats gracefully.
+
+5. **File Name Validator**: Create a method that checks if a filename is valid (no special characters, not empty). Throw exceptions for invalid names.
diff --git a/content/docs/pt-PT/guides/java-basics/13-inheritance.mdx b/content/docs/pt-PT/guides/java-basics/13-inheritance.mdx
new file mode 100644
index 00000000..1650c27a
--- /dev/null
+++ b/content/docs/pt-PT/guides/java-basics/13-inheritance.mdx
@@ -0,0 +1,629 @@
+---
+title: 13 - Inheritance
+description: Learn how to create class hierarchies and reuse code effectively.
+---
+
+Inheritance lets you create new classes based on existing ones. The new class inherits all the properties and methods of the parent class, and can add its own or modify inherited ones.
+
+## What is Inheritance?
+
+Think of inheritance like a family tree. A child inherits traits from their parent, but can also have their own unique traits.
+
+```java
+// Parent class (superclass)
+public class Entity {
+    protected String name;
+    protected int health;
+    
+    public Entity(String name, int health) {
+        this.name = name;
+        this.health = health;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+    }
+}
+
+// Child class (subclass)
+public class Player extends Entity {
+    private int level;
+    
+    public Player(String name, int health, int level) {
+        super(name, health);  // Call parent constructor
+        this.level = level;
+    }
+    
+    public void levelUp() {
+        level++;
+        System.out.println(name + " leveled up to " + level + "!");
+    }
+}
+```
+
+<Callout type="info" title="Inheritance Terminology">
+  - **Superclass/Parent**: The class being inherited from (Entity)
+  - **Subclass/Child**: The class inheriting (Player)
+  - **extends**: Keyword to inherit from a class
+  - **super**: Keyword to access parent class members
+
+  ```java
+  public class Monster extends Entity {
+      // Monster IS-A Entity
+      // Monster inherits from Entity
+      // Entity is the parent, Monster is the child
+  }
+  ```
+</Callout>
+
+## The extends Keyword
+
+Use `extends` to inherit from a class:
+
+```java
+public class Animal {
+    protected String name;
+    
+    public void makeSound() {
+        System.out.println(name + " makes a sound");
+    }
+}
+
+public class Dog extends Animal {
+    public void wagTail() {
+        System.out.println(name + " wags tail");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Dog dog = new Dog();
+        dog.name = "Buddy";
+        dog.makeSound();  // Inherited from Animal
+        dog.wagTail();    // Dog's own method
+    }
+}
+```
+
+## The super Keyword
+
+`super` refers to the parent class:
+
+### Calling Parent Constructor
+
+```java
+public class Entity {
+    protected String name;
+    
+    public Entity(String name) {
+        this.name = name;
+    }
+}
+
+public class Player extends Entity {
+    private int level;
+    
+    public Player(String name, int level) {
+        super(name);  // Call parent constructor FIRST
+        this.level = level;
+    }
+}
+```
+
+<Callout type="warning" title="Constructor Rules">
+  - `super()` must be the **first** statement in child constructor
+  - If you don't call `super()`, Java automatically calls the no-argument parent constructor
+  - If parent has no no-argument constructor, you MUST call `super()` with arguments
+
+  ```java
+  // Wrong - super() not first
+  public Player(String name, int level) {
+      this.level = level;
+      super(name);  // Error!
+  }
+
+  // Correct
+  public Player(String name, int level) {
+      super(name);  // First statement
+      this.level = level;
+  }
+  ```
+</Callout>
+
+### Calling Parent Methods
+
+```java
+public class Entity {
+    protected int health;
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println("Entity took damage!");
+    }
+}
+
+public class Player extends Entity {
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);  // Call parent version
+        if (health < 20) {
+            System.out.println("Warning: Low health!");
+        }
+    }
+}
+```
+
+## Method Overriding
+
+Child classes can replace parent methods:
+
+```java
+public class Entity {
+    public void attack() {
+        System.out.println("Entity attacks!");
+    }
+}
+
+public class Player extends Entity {
+    @Override  // Good practice to use this annotation
+    public void attack() {
+        System.out.println("Player swings sword!");
+    }
+}
+
+public class Monster extends Entity {
+    @Override
+    public void attack() {
+        System.out.println("Monster bites!");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Player player = new Player();
+        Monster monster = new Monster();
+        
+        player.attack();   // "Player swings sword!"
+        monster.attack();  // "Monster bites!"
+    }
+}
+```
+
+<Callout type="info" title="@Override Annotation">
+  Always use `@Override` when overriding methods:
+
+  - Helps catch typos (if method doesn't exist in parent, you get an error)
+  - Makes code clearer
+  - Good documentation
+
+  ```java
+  // Without @Override - typo not caught
+  public void attac() {  // Typo! Creates new method instead
+      // ...
+  }
+
+  // With @Override - error caught immediately
+  @Override
+  public void attac() {  // Error: method doesn't exist in parent
+      // ...
+  }
+  ```
+</Callout>
+
+## Access Modifiers in Inheritance
+
+- `public` - Accessible everywhere
+- `protected` - Accessible in class and subclasses
+- `private` - Only in the class (not inherited)
+
+```java
+public class Parent {
+    public int publicVar;      // Child can access
+    protected int protectedVar; // Child can access
+    private int privateVar;     // Child CANNOT access
+    
+    private void privateMethod() {
+        // Child cannot call this
+    }
+    
+    protected void protectedMethod() {
+        // Child can call this
+    }
+}
+
+public class Child extends Parent {
+    public void test() {
+        publicVar = 10;      // OK
+        protectedVar = 20;   // OK
+        privateVar = 30;     // Error!
+        
+        protectedMethod();   // OK
+        privateMethod();     // Error!
+    }
+}
+```
+
+## Practical Examples
+
+### Game Entity Hierarchy
+
+```java
+// Base class for all entities
+public class Entity {
+    protected String name;
+    protected int health;
+    protected int maxHealth;
+    protected double x, y, z;
+    
+    public Entity(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        if (health < 0) health = 0;
+        System.out.println(name + " took " + damage + " damage. Health: " + health);
+    }
+    
+    public boolean isAlive() {
+        return health > 0;
+    }
+    
+    public void moveTo(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        System.out.println(name + " moved to (" + x + ", " + y + ", " + z + ")");
+    }
+}
+
+// Player extends Entity
+public class Player extends Entity {
+    private int level;
+    private int experience;
+    private int mana;
+    
+    public Player(String name) {
+        super(name, 100);
+        this.level = 1;
+        this.experience = 0;
+        this.mana = 50;
+    }
+    
+    public void gainExperience(int amount) {
+        experience += amount;
+        System.out.println("Gained " + amount + " XP");
+        
+        if (experience >= level * 100) {
+            levelUp();
+        }
+    }
+    
+    private void levelUp() {
+        level++;
+        maxHealth += 10;
+        health = maxHealth;
+        mana += 5;
+        System.out.println("Level up! Now level " + level);
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        if (health < maxHealth * 0.25) {
+            System.out.println("⚠ WARNING: Low health!");
+        }
+    }
+}
+
+// Monster extends Entity
+public class Monster extends Entity {
+    private int attackPower;
+    private String type;
+    
+    public Monster(String name, int health, int attackPower, String type) {
+        super(name, health);
+        this.attackPower = attackPower;
+        this.type = type;
+    }
+    
+    public int attack() {
+        System.out.println(name + " attacks!");
+        return attackPower;
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        if (!isAlive()) {
+            System.out.println(name + " was defeated!");
+        }
+    }
+}
+
+// Boss extends Monster (multi-level inheritance)
+public class Boss extends Monster {
+    private int phase;
+    
+    public Boss(String name, int health, int attackPower) {
+        super(name, health, attackPower, "Boss");
+        this.phase = 1;
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        
+        // Change phase at 50% health
+        if (phase == 1 && health < maxHealth / 2) {
+            phase = 2;
+            System.out.println(name + " enters PHASE 2!");
+        }
+    }
+    
+    @Override
+    public int attack() {
+        int damage = super.attack();
+        if (phase == 2) {
+            damage *= 2;
+            System.out.println("ENRAGED ATTACK!");
+        }
+        return damage;
+    }
+}
+```
+
+### Item Hierarchy
+
+```java
+// Base Item class
+public class Item {
+    protected String name;
+    protected int value;
+    protected double weight;
+    
+    public Item(String name, int value, double weight) {
+        this.name = name;
+        this.value = value;
+        this.weight = weight;
+    }
+    
+    public void use() {
+        System.out.println("Using " + name);
+    }
+    
+    public String getInfo() {
+        return name + " ($" + value + ", " + weight + " kg)";
+    }
+}
+
+// Weapon extends Item
+public class Weapon extends Item {
+    private int damage;
+    private int durability;
+    
+    public Weapon(String name, int value, double weight, int damage, int durability) {
+        super(name, value, weight);
+        this.damage = damage;
+        this.durability = durability;
+    }
+    
+    @Override
+    public void use() {
+        if (durability > 0) {
+            System.out.println("Attacking with " + name + " for " + damage + " damage!");
+            durability--;
+        } else {
+            System.out.println(name + " is broken!");
+        }
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Damage: " + damage + ", Durability: " + durability;
+    }
+}
+
+// Consumable extends Item
+public class Consumable extends Item {
+    private int healAmount;
+    private int uses;
+    
+    public Consumable(String name, int value, double weight, int healAmount, int uses) {
+        super(name, value, weight);
+        this.healAmount = healAmount;
+        this.uses = uses;
+    }
+    
+    @Override
+    public void use() {
+        if (uses > 0) {
+            System.out.println("Used " + name + ", restored " + healAmount + " health!");
+            uses--;
+        } else {
+            System.out.println("No " + name + " left!");
+        }
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Heals: " + healAmount + ", Uses: " + uses;
+    }
+}
+
+// Armor extends Item
+public class Armor extends Item {
+    private int defense;
+    private String slot;
+    
+    public Armor(String name, int value, double weight, int defense, String slot) {
+        super(name, value, weight);
+        this.defense = defense;
+        this.slot = slot;
+    }
+    
+    @Override
+    public void use() {
+        System.out.println("Equipped " + name + " (+" + defense + " defense)");
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Defense: " + defense + ", Slot: " + slot;
+    }
+}
+```
+
+## Polymorphism
+
+Child objects can be treated as parent objects:
+
+```java
+Entity entity1 = new Player("Alice");
+Entity entity2 = new Monster("Goblin", 50, 10, "Hostile");
+Entity entity3 = new Boss("Dragon", 500, 50);
+
+// All can use Entity methods
+entity1.takeDamage(10);
+entity2.takeDamage(10);
+entity3.takeDamage(10);
+
+// Array of different types
+Entity[] entities = {
+    new Player("Bob"),
+    new Monster("Zombie", 30, 8, "Hostile"),
+    new Monster("Spider", 20, 5, "Hostile")
+};
+
+// Process all entities the same way
+for (Entity entity : entities) {
+    entity.takeDamage(5);
+}
+```
+
+<Callout type="info" title="Polymorphism Benefits">
+  Polymorphism lets you write code that works with parent types but handles child types correctly:
+
+  ```java
+  public void damageEntity(Entity entity, int damage) {
+      entity.takeDamage(damage);
+      // Works for Player, Monster, Boss, etc.
+      // Each uses their own version of takeDamage()
+  }
+
+  // Can call with any Entity type
+  damageEntity(new Player("Alice"), 10);
+  damageEntity(new Monster("Goblin", 50, 10, "Hostile"), 10);
+  damageEntity(new Boss("Dragon", 500, 50), 10);
+  ```
+</Callout>
+
+## The Object Class
+
+All classes in Java automatically inherit from `Object`:
+
+```java
+public class MyClass {
+    // Automatically extends Object
+    // Has methods like toString(), equals(), etc.
+}
+```
+
+Common Object methods to override:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    
+    @Override
+    public String toString() {
+        return "Player: " + name + " (Lv. " + level + ")";
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Player) {
+            Player other = (Player) obj;
+            return this.name.equals(other.name);
+        }
+        return false;
+    }
+}
+```
+
+## Final Classes and Methods
+
+`final` prevents inheritance or overriding:
+
+```java
+// Final class - cannot be extended
+public final class SpecialItem {
+    // No class can extend this
+}
+
+// Final method - cannot be overridden
+public class Entity {
+    public final void printName() {
+        System.out.println(name);
+    }
+}
+
+public class Player extends Entity {
+    @Override
+    public void printName() {  // Error! Method is final
+        // Cannot override
+    }
+}
+```
+
+## Common Mistakes
+
+```java
+// Wrong - Forgetting super()
+public class Player extends Entity {
+    public Player(String name) {
+        // Error! Entity has no no-arg constructor
+    }
+}
+
+// Correct
+public class Player extends Entity {
+    public Player(String name) {
+        super(name, 100);  // Call parent constructor
+    }
+}
+
+// Wrong - Accessing private members
+public class Child extends Parent {
+    public void test() {
+        privateVar = 10;  // Error! private is not inherited
+    }
+}
+
+// Correct - Use protected
+public class Parent {
+    protected int protectedVar;  // Child can access
+}
+
+// Wrong - Multiple inheritance (not allowed in Java)
+public class Child extends Parent1, Parent2 {  // Error!
+}
+
+// Correct - Single inheritance only
+public class Child extends Parent {
+}
+```
+
+## Practice Exercises
+
+1. **Vehicle Hierarchy**: Create a `Vehicle` class with properties like speed and fuel. Create `Car` and `Motorcycle` subclasses with their own unique features.
+
+2. **Shape Calculator**: Create a `Shape` class with a `calculateArea()` method. Create `Circle`, `Rectangle`, and `Triangle` subclasses that override this method.
+
+3. **RPG Characters**: Create a `Character` class. Extend it to make `Warrior`, `Mage`, and `Archer` classes with unique abilities.
+
+4. **Animal Sounds**: Create an `Animal` class with a `makeSound()` method. Create various animal subclasses that override this method.
diff --git a/content/docs/pt-PT/guides/learning-to-learn.mdx b/content/docs/pt-PT/guides/learning-to-learn.mdx
index 73d3fd14..567e514e 100644
--- a/content/docs/pt-PT/guides/learning-to-learn.mdx
+++ b/content/docs/pt-PT/guides/learning-to-learn.mdx
@@ -1,12 +1,19 @@
 ---
 title: Learning to Learn
 description: A guide to help you become a better learner and adapt to new information effectively.
+icon: CircleQuestionMark
 ---
 
 ## Why learn to code? We have visual scripting!
 
 Yes we do, and honestly you should try that out. Visual scripting is a great addition to Hytale and we know it'll be powerful, but nothing beats the ability of being able to read and write Java code, with the ability to build even more powerful mods and plugins.
 
+<Callout type="info" title="Visual Scripting vs Coding">
+  Visual scripting is great for beginners and for simple tasks, but coding allows for more complex and efficient solutions. Learning to code opens up a wider range of possibilities for modding Hytale.
+
+  We will have guides on visual scripting when Hytale releases from Day 1.
+</Callout>
+
 ## Should everyone trying to mod Hytale learn how to code?
 
 No one should feel like they HAVE to learn to code to make stuff in Hytale. Simon and his team have validated this time and time again with their strives in graph editors and visual scripting. You can change mob behavior, world generation, etc. all with just these tools.
@@ -15,15 +22,16 @@ But if you're looking to build more complex things (from utilities to entirely c
 
 ## Okay, I'm interested. What's to come?
 
-Over the course of these next several lessons you'll learn the basics of coding, whether it be in Python or jumping straight into Java, plus how to setup your environment for building mods and what resources to look to for extending your knowledge.
+Over the course of these next several lessons you'll learn the basics of coding, how to read documentation, and how to find resources to help you learn more on your own.
 
-The guides' themselves will be take a very big "birds eye view" approach to things and provide links to resources to do the actual coding. This is done because, quite frankly, enough resources exist on how to learn this stuff, it's just the act of finding the right stuff on Google that can be hard. Learning to be able to code without guidance is the goal. The Hytale Modding community is always there to help you, but to become a truly well rounded developer, you'll have to pick up a lot of this stuff just by reading from resources.
+The guides themselves will take a very big "bird's-eye view" approach to things and provide links to resources to do the actual coding. This is done because, quite frankly, enough resources exist on how to learn this stuff, it's just the act of finding the right stuff on Google that can be hard. Learning to be able to code without guidance is the goal. The Hytale Modding community is always there to help you, but to become a truly well rounded developer, you'll have to pick up a lot of this stuff just by reading from resources.
 
-## Any closing thoughts?
+<Callout type="info" title="Finding Resources">
+  We have created a small Java Basics series to help you get started with the language itself, but beyond that, you'll be expected to find your own resources to learn more. We recommend sites like [w3schools](https://www.w3schools.com/java/) and [GeeksforGeeks](https://www.geeksforgeeks.org/java/) as great starting points.
+</Callout>
 
-Remember, learning to code is hard. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come.
+Our goal is to teach you how to Mod Hytale, and that will always be our goal. This is the reason we can't teach you everything about Java or programming in general. Instead, we want to give you the tools to be able to learn on your own, so you can continue to grow as a developer even after you've completed our guides.
 
-<Callout>
-  Credit: @grayvoxdev on the HytaleModding
-  Discord
-</Callout>
+## Any closing thoughts?
+
+Remember, learning to code is hard. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come. Happy coding!
diff --git a/content/docs/pt-PT/guides/plugin/block-components.mdx b/content/docs/pt-PT/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/pt-PT/guides/plugin/browsing-serverjar.mdx b/content/docs/pt-PT/guides/plugin/browsing-serverjar.mdx
new file mode 100644
index 00000000..240ed19a
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/browsing-serverjar.mdx
@@ -0,0 +1,111 @@
+---
+title: Browsing the server.jar code
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
+---
+
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
+
+## Why?
+
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
+
+- Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
+  one of these:
+
+  - `python -m venv .venv`
+  - `python3 -m venv .venv` (Linux)
+  - `py -3.13 -m venv .venv` (Windows)
+
+  In the last one, specifying the version is recommended if you have multiple Pythons installed.
+
+- Activate the virtual environment:
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
+  - Linux/Mac: `source .venv/bin/activate`
+  - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
+
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
+  - `pip install -r requirements.txt`
+
+- Install these dependencies and ensure they are on PATH:
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
+  - `java` you need JDK 25 or newer
+  - `jar` (comes with JDK inside the bin folder)
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
+
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
+
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+
+Then run this:
+
+```shell
+python run.py setup
+```
+
+What will it do:
+
+- copy the HytaleServer.jar into `work/download`
+  - (on Windows) fix `META-INF/license` name collision
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
+- set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
+
+You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
+you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
+
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
+![_readme_images/img.png](/assets/reload-maven.png)\
+It is located in the "m" icon on the right side:\
+![_readme_images/m.png](/assets/maven.png)\
+If you don't see it, enable it under View -> Tool Windows -> Maven.\
+![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
diff --git a/content/docs/pt-PT/guides/plugin/build-and-test.mdx b/content/docs/pt-PT/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/pt-PT/guides/plugin/chat-formatting.mdx b/content/docs/pt-PT/guides/plugin/chat-formatting.mdx
new file mode 100644
index 00000000..c967fc0f
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/chat-formatting.mdx
@@ -0,0 +1,199 @@
+---
+title: Formatting the chat
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+![chat format example](/assets/guides/chat-example.png)
+
+The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
+You can cancel this event as well as modify the content and the formatter.
+
+## Manual Formatting (Standard Approach)
+
+```java
+public class ChatFormatter {
+
+  public static void onPlayerChat(PlayerChatEvent event) {
+    PlayerRef sender = event.getSender();
+    if(event.getContent().equalsIgnoreCase("poo")) {
+      event.setCancelled(true);
+      sender.sendMessage(Message.raw("Hey, you cannot say that!").color(Color.RED));
+    }
+
+    if(event.getContent().equalsIgnoreCase("you stink")) {
+      event.setContent("i stink");
+    }
+
+    event.setFormatter((playerRed, message) ->
+        Message.join(
+            Message.raw("[COOL] ").color(Color.RED),
+            Message.raw(sender.getUsername()).color(Color.YELLOW),
+            Message.raw(" : " + message).color(Color.PINK)
+        ));
+
+  }
+}
+```
+
+The formatter is the following interface:
+
+```java
+  public interface Formatter {
+    @Nonnull
+    Message format(@Nonnull PlayerRef playerRef, @Nonnull String message);
+  }
+}
+```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/pt-PT/guides/plugin/client-inputs-reference.mdx b/content/docs/pt-PT/guides/plugin/client-inputs-reference.mdx
new file mode 100644
index 00000000..a9f2f085
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/client-inputs-reference.mdx
@@ -0,0 +1,94 @@
+---
+title: "Packets: Client-to-Server Reference"
+description: Complete reference for every packet the client can send to the server.
+authors:
+  - name: Vibe Theory & musava
+    url: https://discord.com/users/145420279294722048
+---
+
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/pt-PT/guides/plugin/creating-block.mdx b/content/docs/pt-PT/guides/plugin/creating-block.mdx
new file mode 100644
index 00000000..07b909ad
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/creating-block.mdx
@@ -0,0 +1,101 @@
+---
+title: Creating custom blocks
+description: Learn how to create custom blocks for your Hytale mod.
+authors:
+  - name: Flo_12344
+    url: https://flotterstudio.com
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating custom blocks requires enabling asset packs and organizing your files properly.
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" />
+      </Folder>
+
+      <Folder name="Languages" defaultOpen>
+        <Folder name="en-US" />
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" />
+
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="my_new_block" defaultOpen>
+          <File name="model.blockymodel" />
+        </Folder>
+      </Folder>
+
+      <Folder name="BlockTextures" defaultOpen>
+        <File name="texture.png" />
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+3. Add translations in `Server/Languages/en-US/items.lang`:
+
+```
+my_new_block.name = My New Block
+my_new_block.description = My Description
+```
+
+## Basic Cube Block
+
+Create `Server/Item/Items/my_new_block.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "items.my_new_block.name",
+    "Description": "items.my_new_block.description"
+  },
+  "Id": "My_New_Block",
+  "MaxStack": 100,
+  "Icon": "Icons/ItemsGenerated/my_new_block.png",
+  "Categories": [
+    "Blocks.Rocks"
+  ],
+
+  "PlayerAnimationsId": "Block",
+  "Set": "Rock_Stone",
+  "BlockType": {
+    "Material": "Solid",
+    "DrawType": "Cube",
+    "Group": "Stone",
+    "Flags": {},
+    "Gathering": {
+      "Breaking": {
+        "GatherType": "Rocks",
+        "ItemId": "my_new_block"
+      }
+    },
+    "BlockParticleSetId": "Stone",
+    "Textures": [
+      {
+        "All": "BlockTextures/my_new_block.png"
+      }
+    ],
+    "ParticleColor": "#aeae8c",
+    "BlockSoundSetId": "Stone",
+    "BlockBreakingDecalId": "Breaking_Decals_Rock"
+  },
+  "ResourceTypes": [
+    {
+      "Id": "Rock"
+    }
+  ]
+}
+```
+
+Ensure all referenced files exist in their respective folders, and the paths are correct.
diff --git a/content/docs/pt-PT/guides/plugin/creating-commands.mdx b/content/docs/pt-PT/guides/plugin/creating-commands.mdx
new file mode 100644
index 00000000..f9881d9d
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/creating-commands.mdx
@@ -0,0 +1,421 @@
+---
+title: Creating Commands
+description: Learn how to create custom commands for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
+---
+
+In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
+
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
+
+To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
+
+You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
+
+You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
+
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
+```java
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType()); // also a component
+    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+    TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+    player.sendMessage(Message.raw("Player#getUuid() : " + player.getUuid())); // returns UUID from UUIDComponent
+    player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+    player.sendMessage(Message.raw("equal : " + player.getUuid().equals(component.getUuid()))); // they're both the same
+    player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+  }
+
+}
+```
+
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
+## Registering the Command
+
+For any command
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // One way to add commands
+        this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
+    }
+}
+```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/pt-PT/guides/plugin/creating-configuration-file.mdx b/content/docs/pt-PT/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/pt-PT/guides/plugin/creating-events.mdx b/content/docs/pt-PT/guides/plugin/creating-events.mdx
new file mode 100644
index 00000000..ea7abdc2
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/creating-events.mdx
@@ -0,0 +1,90 @@
+---
+title: Creating Events
+description: Learn how to create custom events for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: EllieAU
+    url: https://ellie.au
+---
+
+## Event Class
+
+You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+
+Example plugin when a player is ready (joins a server):
+
+```java
+
+public class ExampleEvent {
+
+    public static void onPlayerReady(PlayerReadyEvent event) {
+        Player player = event.getPlayer();
+        player.sendMessage(Message.raw("Welcome " + player.getDisplayName()));
+    }
+
+}
+```
+
+## Registering the Event
+
+You need to register all events you make in the Main plugin class, usually in the `setup` function.
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        this.getEventRegistry().registerGlobal(PlayerReadyEvent.class, ExampleEvent::onPlayerReady);
+    }
+}
+```
+
+## ECS Event Classes
+
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
+
+```java
+class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent.Pre> {
+    public ExampleCancelCraft() {
+        super(CraftRecipeEvent.Pre.class);
+    }
+
+    @Override
+    public void handle(int index,
+                       @NonNullDecl ArchetypeChunk<EntityStore> archetypeChunk,
+                       @NonNullDecl Store<EntityStore> store,
+                       @NonNullDecl CommandBuffer<EntityStore> commandBuffer,
+                       @NonNullDecl CraftRecipeEvent.Pre craftRecipeEvent) {
+        CraftingRecipe recipe = craftRecipeEvent.getCraftedRecipe();
+        if (recipe.getInput() != null) {
+            for (MaterialQuantity mq : recipe.getInput()) {
+                if (Objects.equals(mq.getItemId(), "Ingredient_Fibre")) {
+                    craftRecipeEvent.setCancelled(true);
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Archetype.empty();
+    }
+}
+```
+
+## Registering ECS Events
+
+You will need to register the system in your plugin:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        this.getEntityStoreRegistry().registerSystem(new ExampleCancelCraft());
+    }
+}
+```
diff --git a/content/docs/pt-PT/guides/plugin/customizing-camera-controls.mdx b/content/docs/pt-PT/guides/plugin/customizing-camera-controls.mdx
new file mode 100644
index 00000000..e98c7777
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/customizing-camera-controls.mdx
@@ -0,0 +1,170 @@
+---
+title: Customizing Camera Controls
+description: Intro to custom camera modding.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+## The Basics
+
+Hytale provides great camera customizability! Heres the essentials to get started.
+
+Camera is controlled by sending a `SetServerCamera` packet with `ServerCameraSettings`:
+
+```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)
+);
+```
+
+This gives you a simple third-person camera. The presets below show more complete configurations.
+
+**Reset to default:**
+
+```java
+playerRef.getPacketHandler().writeNoCache(
+    new SetServerCamera(ClientCameraView.Custom, false, null)
+);
+```
+
+---
+
+## Camera Presets
+
+### Top-Down (RTS/ARPG Style)
+
+_Source: `com.hypixel.hytale.server.core.command.commands.player.camera.PlayerCameraTopdownCommand`_
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.distance = 20.0f;
+settings.displayCursor = true;
+settings.isFirstPerson = false;
+settings.movementForceRotationType = MovementForceRotationType.Custom;
+// Align movement with camera yaw (horizontal rotation only)
+settings.movementForceRotation = new Direction(-0.7853981634f, 0.0f, 0.0f);  // 45° left
+settings.eyeOffset = true;
+settings.positionDistanceOffsetType = PositionDistanceOffsetType.DistanceOffset;
+settings.rotationType = RotationType.Custom;
+settings.rotation = new Direction(0.0f, -1.5707964f, 0.0f);  // Look straight down
+settings.mouseInputType = MouseInputType.LookAtPlane;
+settings.planeNormal = new Vector3f(0.0f, 1.0f, 0.0f);       // Ground plane
+```
+
+### Side-Scroller (2D Platformer Style)
+
+_Source: `com.hypixel.hytale.server.core.command.commands.player.camera.PlayerCameraSideScrollerCommand`_
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.distance = 15.0f;
+settings.displayCursor = true;
+settings.isFirstPerson = false;
+settings.movementForceRotationType = MovementForceRotationType.Custom;
+settings.movementMultiplier = new Vector3f(1.0f, 1.0f, 0.0f);  // Lock Z-axis
+settings.eyeOffset = true;
+settings.positionDistanceOffsetType = PositionDistanceOffsetType.DistanceOffset;
+settings.rotationType = RotationType.Custom;
+settings.mouseInputType = MouseInputType.LookAtPlane;
+settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
+```
+
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
+## Common Settings Explained
+
+### Position & Rotation
+
+- **`positionLerpSpeed`** (0.0-1.0): How smoothly the camera follows the player. Lower = smoother but slower response.
+- **`rotationLerpSpeed`** (0.0-1.0): How smoothly the camera rotates. Lower = smoother but slower response.
+- **`distance`**: Camera distance from player. Higher = zoomed out more.
+- **`rotation`**: Camera angle as `Direction(yaw, pitch, roll)` in radians.
+- **`rotationType`**: How rotation is calculated. `RotationType.Custom` uses your `rotation` value.
+
+### Movement Alignment
+
+- **`movementForceRotationType`**:
+- `MovementForceRotationType.AttachedToHead` = movement follows where player looks
+- `MovementForceRotationType.Custom` = use `movementForceRotation` value
+- **`movementForceRotation`**: When using `Custom`, this sets the direction for W/S movement. Match yaw with camera but keep pitch at 0.
+
+### Input & Display
+
+- **`displayCursor`**: Show/hide mouse cursor.
+- **`mouseInputType`**:
+- `MouseInputType.LookAtPlane` = mouse moves cursor on a plane (good for top-down)
+- `MouseInputType.LookAtTarget` = mouse rotates camera
+- **`planeNormal`**: For `LookAtPlane`, defines which plane the mouse moves on. `(0,1,0)` = ground plane.
+
+### Advanced
+
+- **`positionDistanceOffsetType`**:
+- `DistanceOffset` = simple distance offset
+- `DistanceOffsetRaycast` = prevents camera clipping through walls
+- **`eyeOffset`**: Offset camera from player's eye position.
+- **`movementMultiplier`**: Scale movement on each axis. `(1,1,0)` = lock Z-axis for 2D movement.
+
+---
+
+## Imports
+
+```java
+import com.hypixel.hytale.protocol.ClientCameraView;
+import com.hypixel.hytale.protocol.Direction;
+import com.hypixel.hytale.protocol.MouseInputType;
+import com.hypixel.hytale.protocol.MovementForceRotationType;
+import com.hypixel.hytale.protocol.PositionDistanceOffsetType;
+import com.hypixel.hytale.protocol.RotationType;
+import com.hypixel.hytale.protocol.ServerCameraSettings;
+import com.hypixel.hytale.protocol.Vector3f;
+import com.hypixel.hytale.protocol.packets.camera.SetServerCamera;
+```
+
+---
+
+## Tips
+
+- **Zoom:** Adjust `distance` (higher = further out)
+- **Smoothness:** `positionLerpSpeed` and `rotationLerpSpeed` control how quickly the camera catches up to its target
+- **Wall clipping:** Use `PositionDistanceOffsetType.DistanceOffsetRaycast`
+- **Lock camera:** Set `isLocked = true` in the packet to prevent player changes
+- **2D movement:** Set `movementMultiplier` to zero out an axis
+- **Isometric cameras:** Always set `movementForceRotation` to match camera yaw for proper movement alignment
+- **Angle calculations:** Use `Math.toRadians(degrees)` or `degrees * Math.PI / 180.0` to convert degrees to radians
+
+---
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/pt-PT/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/pt-PT/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/pt-PT/guides/plugin/instances.mdx b/content/docs/pt-PT/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/pt-PT/guides/plugin/inventory-management.mdx b/content/docs/pt-PT/guides/plugin/inventory-management.mdx
new file mode 100644
index 00000000..e38c644f
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/inventory-management.mdx
@@ -0,0 +1,125 @@
+---
+title: Inventory Management
+description: Learn how to manage player inventories in your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+---
+
+In this guide, you'll learn how to manage player inventories in your Hytale mod.
+
+## Accessing the Player Inventory
+
+To access the Inventory of a `Player`, you can use the `getInventory()` method which returns the `Inventory` object.
+
+```java
+Inventory inventory = player.getInventory();
+```
+
+## Opening Inventories
+
+You can open different types of inventories, these inventories are known as "Pages". You can also add custom pages, this will be covered in a guide later on.
+
+You can use the `Page` enum to reference existing inventories, currently the following pages are available:
+
+- `Page.None`
+- `Page.Bench`
+- `Page.Inventory`
+- `Page.ToolsSettings`
+- `Page.Map`
+- `Page.MachinimaEditor`
+- `Page.ContentCreation`
+- `Page.Custom`
+
+```java
+PageManager pageManager = player.getPageManager();
+Store<EntityStore> store = player.getWorld().getEntityStore().getStore();
+pageManager.setPage(player.getReference(), store, Page.Inventory);
+```
+
+## `ItemStack` Class
+
+You can create and manipulate items in a player's inventory using the `ItemStack` class. This class represents a stack of items, and provides methods for managing the quantity and type of items in the stack.
+
+### Creating an ItemStack
+
+To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
+
+```java
+ItemStack item = new ItemStack("Stone");
+ItemStack withQuantity = new ItemStack("Stone", 64);
+```
+
+#### Adding custom metadata
+
+You can also add custom metadata to a `ItemStack` by passing a `BsonDocument` when creating it.
+
+```java
+BsonDocument metadata = new BsonDocument();
+metadata.append("customData", new BsonString("value"));
+ItemStack item = new ItemStack("Stone", 64, metadata);
+```
+
+### Setting a durability
+
+```java
+ItemStack stackWithDurability = new ItemStack(
+    "DiamondSword", // itemId
+    1,              // quantity
+    100.0,          // durability
+    100.0,          // maxDurability
+    metadata        // metadata (optional)
+);
+```
+
+## Getting the `ItemContainer`
+
+The `Inventory` class provides methods to get multiple `ItemContainer` objects, like:
+
+- `.getStorage()`
+- `.getArmor()`
+- `.getBackpack()`
+- `.getHotbar()`
+- `.getUtility()`
+
+There are also combined methods like:
+
+- `.getCombinedEverything()`
+- `.getCombinedArmorHotbarStorage()`
+- `.getCombinedBackpackStorageHotbar()`
+- `.getCombinedHotbarFirst()`
+- `.getCombinedStorageFirst()`
+- `.getCombinedArmorHotbarUtilityStorage()`
+- `.getCombinedHotbarUtilityConsumableStorage()`
+
+## Adding `ItemStack` objects to the Inventory
+
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
+
+```java
+Inventory inventory = player.getInventory();
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
+```
+
+Or you can specify a certain slot to add it to:
+
+```java
+storageContainer.addItemStackToSlot((short) 4, stack)
+```
+
+## Removing `ItemStack` objects from the Inventory
+
+To remove an `ItemStack` from a player's inventory, you can use the `removeItemStack()` method of the `Inventory` class.
+
+```java
+Inventory inventory = player.getInventory();
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
+```
+
+Or you can specify a certain slot to remove it from:
+
+```java
+storageContainer.removeItemStackFromSlot((short) 4);
+```
diff --git a/content/docs/pt-PT/guides/plugin/item-interaction.mdx b/content/docs/pt-PT/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/pt-PT/guides/plugin/listening-to-packets.mdx b/content/docs/pt-PT/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/pt-PT/guides/plugin/logging.mdx b/content/docs/pt-PT/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/pt-PT/guides/plugin/permission-management.mdx b/content/docs/pt-PT/guides/plugin/permission-management.mdx
new file mode 100644
index 00000000..70aef22c
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/permission-management.mdx
@@ -0,0 +1,118 @@
+---
+title: Permission Management
+description: Learn how to manage permission nodes and groups in your Hytale plugin.
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: Craw
+    link: https://discord.com/users/292656109939064833
+---
+
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+
+## The `PermissionsModule` class
+
+The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+
+- Add permissions to user
+- Remove permissions from user
+- Add permissions to group (this also creates the group if it doesn't exist)
+- Remove permissions from group
+- Add user to group
+- Remove user from group
+- List all groups for a user
+- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+
+With this class you cannot:
+
+- List all defined groups
+- Remove a group
+
+### Adding Permission Nodes
+
+You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+
+```java
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addUserPermission(playerUUID, permissions);
+```
+
+### Removing Permission Nodes
+
+Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+
+```java
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeUserPermission(playerUUID, permissions);
+```
+
+### Add permissions to group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addGroupPermission(groupName, permissions);
+```
+
+### Remove permissions from group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeGroupPermission(groupName, permissions);
+```
+
+### Add user to group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addUserToGroup(playerUUID, groupName);
+```
+
+### Remove user from group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeUserFromGroup(playerUUID, groupName);
+```
+
+### List all groups for a user
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+perms.getGroupsForUser(playerUUID);
+```
+
+### Check Permission Nodes
+
+To check if a player has a specific permission node, you can use the `hasPermission` method.
+
+```java
+boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+```
+
+### Additional: Defining your own storage provider for permissions and groups
+
+Apparently we could implement our own storage provider for permissions and groups as file storage is not very reliable.
+
+First we need to define a provider class that implements PermissionProvider:
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider
+```
+
+Then we just implement the required methods using a database implementation. To force our plugin to use this new provider we just need to add to the provider list our fresh DatabasePermissionProvider.
+
+```java
+perms.getProviders().addFirst(new DatabasePermissionProvider());
+```
diff --git a/content/docs/pt-PT/guides/plugin/player-death-event.mdx b/content/docs/pt-PT/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/pt-PT/guides/plugin/player-input-guide.mdx b/content/docs/pt-PT/guides/plugin/player-input-guide.mdx
new file mode 100644
index 00000000..c9cc1419
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/player-input-guide.mdx
@@ -0,0 +1,68 @@
+---
+title: Player Input Guide
+description: Learn how to handle player input.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
+---
+
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
+
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
+
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
+
+```java
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
+        }
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
+        }
+    }
+}
+```
+
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/pt-PT/guides/plugin/player-stats.mdx b/content/docs/pt-PT/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/pt-PT/guides/plugin/playing-sounds.mdx b/content/docs/pt-PT/guides/plugin/playing-sounds.mdx
new file mode 100644
index 00000000..7ce614b8
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/playing-sounds.mdx
@@ -0,0 +1,64 @@
+---
+title: Playing Sounds
+description: Learn how to Play Sounds with your Hytale Plugin
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+In this guide, you will learn how to play sounds to a player.
+
+## Sound Indexes
+
+We currently have a lot of Sounds available to be used as a key in the AssetMap, [click here](../../server/sounds) to see the full list of available sounds.
+
+You can use the `getAssetMap()` method from the `SoundEvent` class to get the index of a specified sound:
+
+```java
+int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
+```
+
+## The Transform Component
+
+The `TransformComponent` is the component that tells Hytale where to play the sound. You can get this in multiple ways.
+
+1. Getting the Transform Component from the `Player` object
+
+```java
+TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+```
+
+2. Generating a new TransformComponent (although this is not recommended, as if your player is not close enough they won't hear the sound)
+
+```java
+Vector3d vector3d = new Vector3d(0, 0, 0); // position
+Vector3f vector3f = new Vector3f(0, 0, 0); // rotation
+TransformComponent transform = new TransformComponent(vector3d, vector3f);
+```
+
+### PlayerRef
+
+You need a Player Reference, which is a instance of `Ref<EntityStore>`. If you have the `Player` object, you can use the `getReference()` method to get a Player Reference
+
+### World
+
+You need a World reference, as the sound needs to be played inside the `execute()` method from the `World` class.
+
+### SoundCategory
+
+There is a `SoundCategory` enum that defines different sound categories, such as `Music`, `Ambient`, `SFX` and `UI`. You can use these categories to specify the type of sound you are playing.
+
+## Playing Sounds
+
+You can use the `SoundUtil` class to play sounds, using the `playSoundEvent3dToPlayer` method.
+
+```java
+int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
+World world = player.getWorld();
+EntityStore store = world.getEntityStore();
+Ref<EntityStore> playerRef = player.getReference();
+world.execute(() -> {
+    TransformComponent transform = store.getStore().getComponent(playerRef, EntityModule.get().getTransformComponentType());
+    SoundUtil.playSoundEvent3dToPlayer(playerRef, index, SoundCategory.UI, transform.getPosition(), store.getStore());
+});
+```
diff --git a/content/docs/pt-PT/guides/plugin/send-notifications.mdx b/content/docs/pt-PT/guides/plugin/send-notifications.mdx
new file mode 100644
index 00000000..8eafb96e
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/send-notifications.mdx
@@ -0,0 +1,48 @@
+---
+title: Sending notifications
+description: Learn how to send notifications (similar to item pickup) with your Hytale Plugin
+authors:
+  - name: BeerBag
+---
+
+## Overview
+
+In this guide, you will learn how to send notifications to players, similar to
+the notification received when picking up an item from the ground.
+
+![notification-example](/assets/guides/notification-example.png)
+
+## Structure of a Notification
+
+A notification consists of three main components:
+
+1. **Primary Message**: The main `Message` displayed in the notification.
+2. **Secondary Message**: Additional `Message`, displayed below the primary message.
+3. **Icon**: An item icon that visually represents the notification, shown on
+   the left side.
+
+## Sending Notifications
+
+You can use the `NotificationUtil` class to send notifications to players.
+You will need access to the `PacketHandler` of the player, which can be obtained
+from the `PlayerRef` using the `getPacketHandler()` method (in this example,
+we get the `PlayerRef` from the `Universe` using the player's UUID).
+
+```java
+public static void onPlayerReady(PlayerReadyEvent event) {
+    var player = event.getPlayer();
+
+    var playerRef = Universe.get().getPlayer(player.getUuid());
+    var packetHandler = playerRef.getPacketHandler();
+
+    var primaryMessage = Message.raw("THIS WORKS!!!").color("#00FF00");
+    var secondaryMessage = Message.raw("This is the secondary message").color("#228B22");
+    var icon = new ItemStack("Weapon_Sword_Mithril", 1).toPacket();
+
+    NotificationUtil.sendNotification(
+        packetHandler,
+        primaryMessage,
+        secondaryMessage,
+        (ItemWithAllMetadata) icon);
+}
+```
diff --git a/content/docs/pt-PT/guides/plugin/setting-up-env.mdx b/content/docs/pt-PT/guides/plugin/setting-up-env.mdx
new file mode 100644
index 00000000..8115e634
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/setting-up-env.mdx
@@ -0,0 +1,170 @@
+---
+title: Setting Up Your Development Environment
+description: Learn how to set up your development environment for modding Hytale.
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
+This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
+
+## Prerequisites
+
+Before we begin, make sure you have:
+
+- A computer running Windows 10/11, macOS, or Linux
+- At least 8GB of RAM
+- 10GB of free disk space
+- Administrative privileges on your system
+
+## Required Software
+
+### 1. Java Development Kit (JDK)
+
+Hytale modding requires Java 25 or later. We recommend using OpenJDK.
+
+#### Windows
+
+1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
+2. Run the installer with default settings
+3. Verify installation by opening Command Prompt and running:
+
+```bash
+java -version
+```
+
+#### macOS
+
+```bash
+# Using Homebrew
+brew install openjdk@25
+```
+
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
+#### Linux (Ubuntu/Debian)
+
+```bash
+sudo apt update
+sudo apt install openjdk-25-jdk
+```
+
+### 2. Integrated Development Environment (IDE)
+
+We recommend IntelliJ IDEA Community Edition for Hytale modding.
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+
+1. Visit the official website: https://maven.apache.org/download.cgi
+2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `apache-maven-3.9.12/bin/` folder to your PATH
+
+You can now try the command `mvn -version` to verify Maven is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+## Setting Up Your Workspace
+
+### 1. Clone the Plugin Template
+
+Instead of creating an empty directory, we'll use the official Hytale plugin template:
+
+```bash
+# Clone the template repository
+git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
+cd MyFirstMod
+```
+
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
+
+1. Open IntelliJ IDEA
+2. Click "Open" and navigate to your `MyFirstMod` directory
+3. IntelliJ will automatically detect it as a Maven project
+4. Wait for the project to index and dependencies to download
+
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
+## Next Steps
+
+Now that you have your development environment set up with the plugin template:
+
+1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+2. **Explore the code structure** - Familiarize yourself with the template's organization
+3. **Start modding** - Begin writing your first Hytale plugin!
+
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
+
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/pt-PT/guides/plugin/spawning-entities.mdx b/content/docs/pt-PT/guides/plugin/spawning-entities.mdx
new file mode 100644
index 00000000..e12c0aea
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/spawning-entities.mdx
@@ -0,0 +1,120 @@
+---
+title: Spawning Entities
+description: Learn how to spawn Entities in Hytale
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+In this guide, you will learn how to spawn entities in Hytale. It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding with this guide. You can find the ECS guide [here](./ecs).
+
+## Getting the World Object
+
+You need to first get the `World` object before proceeding with spawning entities. You can get this object in a few ways:
+
+### Using the `Player` Object
+
+You can use the `Player` object to get the `World` object by calling the `getWorld()` method on the `Player` instance.
+
+```java
+World world = player.getWorld();
+```
+
+### Using the `Universe` Class
+
+You can use the `Universe` class to get the `World` object by calling the `getWorld(string UUID)` method on the `Universe` instance.
+
+```java
+World world = Universe.get().getWorld("your-world-uuid");
+```
+
+Once you have the world object, you need to get a instance of `Store<EntityStore>`, you can do so by:
+
+```java
+Store<EntityStore> store = world.getEntityStore().getStore();
+```
+
+## Creating Entities
+
+Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+
+<Callout type="warning">
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
+
+  ```java
+  world.execute(() -> {
+      // run all the code below in this context
+  })
+  ```
+</Callout>
+
+Let's start by creating a blank holder:
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+```
+
+## Getting a Model
+
+You now need a model for your Entity. You can find a list of all entities [here](../../server/entities), we're going to use the Minecart entity for this example:
+
+```java
+ModelAsset modelAsset = ModelAsset.getAssetMap().getAsset("Minecart");
+Model model = Model.createScaledModel(modelAsset, 1.0f);
+```
+
+### The Transform Component
+
+The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
+
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
+
+```java
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
+```
+
+2. Generating a new TransformComponent
+
+```java
+Vector3d vector3d = new Vector3d(0, 0, 0); // position
+Vector3f vector3f = new Vector3f(0, 0, 0); // rotation
+TransformComponent transform = new TransformComponent(vector3d, vector3f);
+```
+
+## Adding Components to our Entity
+
+Now we need to add all the components we made above to our entity, here's all the components we need to add one by one:
+
+```java
+
+holder.addComponent(TransformComponent.getComponentType(), new TransformComponent(vector3d, new Vector3f(0, 0, 0)));
+holder.addComponent(PersistentModel.getComponentType(), new PersistentModel(model.toReference()));
+holder.addComponent(ModelComponent.getComponentType(), new ModelComponent(model));
+holder.addComponent(BoundingBox.getComponentType(), new BoundingBox(model.getBoundingBox()));
+holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+holder.addComponent(Interactions.getComponentType(), new Interactions()); // you need to add interactions here if you want your entity to be interactable
+```
+
+### Ensuring Hytale's Components are present
+
+These act as "configuration" or "default" components that Hytale expects to be present on all entities.
+
+```java
+holder.ensureComponent(UUIDComponent.getComponentType());
+holder.ensureComponent(Interactable.getComponentType()); // if you want your entity to be interactable
+```
+
+## Spawning the Entity
+
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
+
+```java
+store.addEntity(holder, AddReason.SPAWN);
+```
diff --git a/content/docs/pt-PT/guides/plugin/spawning-npcs.mdx b/content/docs/pt-PT/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/pt-PT/guides/plugin/store-persistant-data.mdx b/content/docs/pt-PT/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/pt-PT/guides/plugin/teleporting-players.mdx b/content/docs/pt-PT/guides/plugin/teleporting-players.mdx
new file mode 100644
index 00000000..57cee77f
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/teleporting-players.mdx
@@ -0,0 +1,26 @@
+---
+title: Teleporting the player
+description: Learn how to teleport the player.
+---
+
+To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
+Next, we get the entity store and make a `Teleport` object.
+We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+
+```java
+public static void teleportPlayer(Player player, int x, int y, int z) {
+        World world = player.getWorld();
+        if (world == null) return;
+        world.execute(() -> {
+            if (player.getReference() == null) return;
+            Store<EntityStore> store = player.getReference().getStore();
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
+
+            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
+        });
+
+}
+```
diff --git a/content/docs/pt-PT/guides/plugin/text-hologram.mdx b/content/docs/pt-PT/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/pt-PT/guides/plugin/ui.mdx b/content/docs/pt-PT/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/pt-PT/guides/plugin/world-gen.mdx b/content/docs/pt-PT/guides/plugin/world-gen.mdx
new file mode 100644
index 00000000..4c23b0c9
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/world-gen.mdx
@@ -0,0 +1,143 @@
+---
+title: World Generation System
+description: Learn how to create custom world generation features for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+---
+
+# Overview
+
+This section covers Hytale's procedural world generation systems that creates environments, biomes, and structures dynamically as players explore the world.
+
+Hytale’s world generation is organized into three interconnected systems:
+
+- **Zones** - Large-scale regions that define overall world structure
+- **Biomes** - Terrain characteristics and environmental properties within zones
+- **Caves** - Underground structures and networks generated within zones
+
+These systems work together to create a rich, varied world with smooth transitions and coherent regional themes.
+
+## Getting Started
+
+1. Zone System - Large regions
+2. Biome System - Terrain and environment within zones
+3. Cave System - Underground structures and networks within zones
+
+## Implementation Details
+
+### Zone Lookup and Generation
+
+```java
+
+// Get zone at position
+ZonePatternGenerator zoneGen = /* world generator */;
+ZoneGeneratorResult zoneResult = zoneGen.generate(seed, x, z);
+Zone zone = zoneResult.getZone();
+
+// Get biome within zone
+BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
+Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
+
+// Check for caves in zone
+CaveGenerator caveGen = zone.caveGenerator();
+if (caveGen != null) {
+    CaveType[] caveTypes = caveGen.getCaveTypes();
+    // Generate caves as needed
+}
+```
+
+### Creating a Custom Zone
+
+```java
+// Configure zone discovery
+ZoneDiscoveryConfig discovery = new ZoneDiscoveryConfig(
+    true,                           // Show notification
+    "Custom Zone",                  // Display name
+    "zone.forest.discover",         // Sound event
+    "icons/forest.png",             // Icon
+    true,                           // Major zone
+    5.0f, 2.0f, 1.5f                // Duration, fade in, fade out
+);
+
+// Create biome pattern
+IPointGenerator biomePoints;
+IWeightedMap<TileBiome> tileBiomes;
+CustomBiome[] customBiomes;
+
+BiomePatternGenerator biomeGen = new BiomePatternGenerator(
+    biomePoints,
+    tileBiomes,
+    customBiomes
+);
+
+// Create cave configuration
+CaveType[] caveTypes; // cave definitions
+CaveGenerator caveGen = new CaveGenerator(caveTypes);
+
+// Assemble the zone
+Zone customZone = new Zone(
+    100,                    // Unique ID
+    "new_custom_zone",      // Internal name
+    discovery,              // Discovery config
+    caveGen,                // Cave generator
+    biomeGen,               // Biome pattern
+    uniquePrefabs           // Unique structures
+);
+```
+
+## System Integration
+
+### Zone & Biome Integration
+
+Each zone defines its own biome pattern:
+
+```java
+Zone zone = zoneGen.generate(seed, x, z).getZone();
+BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
+Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
+```
+
+### Zone & Cave Integration
+
+Each zone defines it's own cave patterns:
+
+```java
+Zone zone = /* ... */;
+CaveGenerator caveGen = zone.caveGenerator();
+if (caveGen != null) {
+    // This zone has caves
+    CaveType[] types = caveGen.getCaveTypes();
+}
+```
+
+### Biome & Cave Integration
+
+Caves use biome masks for placement control:
+
+```java
+// Cave type with biome restrictions
+Int2FlagsCondition biomeMask = caveType.getBiomeMask();
+int biomeId = biome.getId();
+int flags = biomeMask.eval(biomeId);
+
+// Check if cave can generate in this biome
+if (CaveBiomeMaskFlags.canGenerate(flags)) {
+    // Generate cave
+}
+```
+
+### Border Transitions
+
+All systems respect zone boundaries:
+
+```java
+ZoneGeneratorResult result = zoneGen.generate(seed, x, z);
+double borderDistance = result.getBorderDistance();
+
+// Fade custom biomes near borders
+if (borderDistance < customBiome.getFadeContainer().getMaskFadeSum()) {
+    double factor = customBiome.getFadeContainer().getMaskFactor(result);
+    // Apply fading
+}
+```
diff --git a/content/docs/pt-PT/guides/prefabs.mdx b/content/docs/pt-PT/guides/prefabs.mdx
new file mode 100644
index 00000000..08404b30
--- /dev/null
+++ b/content/docs/pt-PT/guides/prefabs.mdx
@@ -0,0 +1,92 @@
+---
+title: Prefabs
+description: Documentation about Prefabs in Hytale.
+icon: Box
+authors:
+  - name: Ben Cressman
+    url: https://bencres.dev
+---
+
+# Introduction
+
+Prefabs are Hytale's way of creating reusable structures.
+
+There are a few fundamental concepts to understand about prefabs:
+
+- Users interact with prefabs via a prefab editing world.
+- Prefabs the physical structures in the game world, and are saved as JSON files.
+
+## How to Create a Prefab
+
+Be sure to check the Known Issues section at the end of this guide if you encounter any problems.
+
+1. `/editprefab new <world name>` to create a new prefab editing world: `/editprefab new my_prefab_world`
+   - Note that `my_prefab` is the name of the _world_, not the prefab itself. Worlds can contain multiple prefabs.
+2. Build whatever you want in the prefab editing world.
+3. Use the selection brush to select the area you want to save as a prefab.
+4. `/prefab save` to save the structure as a prefab.
+5. `/editprefab exit` to exit the prefab editing world.
+6. Using the Paste brush, press 'e' on your keyboard to select the prefab you just created. It will be in the "server" dropdown, which can be selected from the top right of the menu.
+   - You can also select it with `/prefab list` and selecting the prefab you just created.
+
+There is a lot more that you can do with prefabs; this is just the basic flow. Keep reading for more information.
+
+## Commands
+
+There are two main commands for prefabs, `/prefab` and `/editprefab`.
+
+This list does not cover the various options for each command. You can use the `--help` flag at the end of any command to see the available options, e.g. `/prefab save --help`, or use `/help` in game and find the `prefab` and `editprefab` commands.
+
+### `/prefab`
+
+This command allows the user to interact with an existing prefab's file.
+
+Subcommands:
+
+- `save`
+  - Saves the prefab to the file system.
+- `load`
+  - Loads the prefab into the game.
+- `delete`
+  - Deletes the prefab from the file system.
+- `list`
+  - Lists all prefabs in the file system.
+
+### `/editprefab`
+
+The `/editprefab` command is used to create or edit the physical structure in the game the prefab is holding.
+
+Subcommands:
+
+- `exit`
+  - Exits the current prefab editing world.
+- `load`
+  - Creates a new prefab editing world to paste an existing prefab into.
+- `new`
+  - Creates a new prefab editing world to create a new prefab from scratch.
+- `select`
+  - Selects the area of the prefab the user is looking at (within 200 blocks).
+- `save`
+  - Saves the current prefab using the existing area, or the currently selected area.
+- `saveui`
+  - Opens the save UI for the current world, allowing the user to interact with all prefabs that are in the world.
+- `kill`
+  - Despawn all entities in the currently selected prefab.
+- `saveas`
+  - Save the selected prefab into a new file.
+- `setbox`
+  - Set the bounding box of the currently selected prefab.
+- `info`
+  - General information about the currently selected prefab.
+- `tp`
+  - Opens the teleport UI to teleport to a prefab in the current editing world.
+- `modified`
+  - Lists all modified prefabs with unsaved changes in the current editing world.
+
+# Known Issues
+
+- After saving edits to an existing prefab, the prefab does not reflect the changes in the game.
+  - Workaround: exit and re-enter the world.
+- When pasting a prefab, the prefab is not always shown accurately.
+  - Workaround: hit 't' on your keyboard to toggle the material being shown; usually at least one view is accurate.
+- `/prefab delete` errors with `Assert not in thread`.
diff --git a/content/docs/pt-PT/official-documentation/npc-doc.mdx b/content/docs/pt-PT/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/pt-PT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/pt-PT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/pt-PT/publishing/builtbybit.mdx b/content/docs/pt-PT/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/pt-PT/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/pt-PT/publishing/curseforge.mdx b/content/docs/pt-PT/publishing/curseforge.mdx
new file mode 100644
index 00000000..d97327d5
--- /dev/null
+++ b/content/docs/pt-PT/publishing/curseforge.mdx
@@ -0,0 +1,71 @@
+---
+title: CurseForge
+description: Learn how to publish your mod to CurseForge
+---
+
+CurseForge is a mod hosting platform, allowing you to share your Hytale mods and creations with players via our website and app.
+
+## 1. Create CurseForge Account
+
+First, [visit our sign-in page](https://curseforge.com/api/v1/auth/login?returnUrl=https://www.curseforge.com/) and either log in to an existing account or click “Create an account”.
+
+This can be done using any Google, Discord, GitHub or Twitch account.
+
+## 2. Create a Project
+
+Now that you're logged in, you can visit our Author Console and navigate to the Projects tab, then click “Create a Project”, either in the sidebar or at the top of the page.
+
+![CurseForge Author Page](/assets/guides/curseforge_author_page.png)
+
+This will then take you to the [project creation](https://authors.curseforge.com/#/projects/create/choose-game) flow. First, select your game (in this case, Hytale) for and the page will be updated with new fields waiting for your inputs. Please see our
+
+[Moderation Policies](https://support.curseforge.com/en/support/solutions/articles/9000197279-moderation-policies#:~:text=General%20CurseForge%20Moderation%20Policies,-Policy\&text=The%20description%20can%20include%20descriptive,the%20game%22%20is%20not%20enough) articles for more information about what is and isn't allowed when creating a new project. Below are the fields along with their descriptions:
+
+- **Name:** This is the title of your project. It should be unique to your project. If the name is already taken, it will be rejected.
+- **Summary:** This is a short blurb about the mod that will show up in the project listings
+- **Description:** This is the longer explanation of what your mod does/adds. Make sure you clearly elaborate on your project. We will reject your project if the description is not grammatically correct or if it does not sufficiently describe the project you are creating. This can be edited later. Note: All titles and descriptions must be in English.
+- **Project License:** This is a drop-down field that contains the most common licenses used in modding games. Research the license type you want to use, including its pros and cons. You can also choose to use a Custom License at the bottom of the dropdown list and enter any text you want.
+- **Class:** This is the root category for your project. Ensure you select the correct one, as it may impact supported file types and app support in CurseForge.
+  - For Hytale, there are four types of Class:
+    - Mods
+      - This is the class that contains both Asset Packs and Plugins, and you should upload either here.
+    - Worlds
+    - Prefabs
+    - Bootstrap
+      - This is the class that contains all Early Plugins.
+- **Main Category:** This is the primary category into which your project will be sorted.
+- **Additional categories:** You can add up to 4 of these. Your project will also show up in lists where people are searching for these types of mods. Be careful, though, if you just add categories that have nothing to do with your mod, we may send it back to you for changes.
+- **Logo Image:** A unique icon to identify your project by.
+
+## 3. Upload a File
+
+Once you've set up your project and filled in the above information, you now need to upload a file to your project for it to enter the moderation queue. To do this, visit the “Files” tab in your Author Console page.
+
+![CurseForge Add Project](/assets/guides/curseforge_add_project.png)
+
+Then, click on “Add File” and upload your mod's file, entering any additional information or meta you wish to include regarding this file.
+
+The file format will depend on the class you select.
+
+### For Plugins
+
+If you're uploading a plugin for Hytale, please make sure you select the "Mods" class and upload your file as a jar file.
+
+### For Packs
+
+If you're uploading a Pack for Hytale, please make sure you select the "Mods" class and upload your file as a ZIP file
+
+### For Worlds
+
+If you're uploading a World for Hytale, make sure you upload it to the "Worlds" class and upload your file as a ZIP file.
+
+**Once you've uploaded your file, it will be sent for our moderation team to review, and once approved, it will be live for all players on CurseForge!**
+
+## 4. Additional Resources & Guides
+
+You can refer to the following resources for guides on how to create a project page, using the upload API, and creating the best project page:
+
+- How to Pass Moderation Review: https://blog.curseforge.com/how-to-pass-moderation-review-on-curseforge-2/
+- Creating and Submitting a Project: https://support.curseforge.com/en/support/solutions/articles/9000197241-creating-and-submitting-a-project
+- How to Create the Best Project Page: https://blog.curseforge.com/how-to-create-the-best-project-page/
+- Our Mod Approval Process: https://blog.curseforge.com/our-mod-approval-process/
diff --git a/content/docs/pt-PT/publishing/index.mdx b/content/docs/pt-PT/publishing/index.mdx
new file mode 100644
index 00000000..fb60fa35
--- /dev/null
+++ b/content/docs/pt-PT/publishing/index.mdx
@@ -0,0 +1,16 @@
+---
+title: Publishing Your Mod
+description: Learn how to publish your mod to the community.
+---
+
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
+
+We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
+
+- [Publishing on Modtale](./publishing/modtale)
+- [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
+
+<Callout>
+  If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
+</Callout>
diff --git a/content/docs/pt-PT/publishing/modtale.mdx b/content/docs/pt-PT/publishing/modtale.mdx
new file mode 100644
index 00000000..3983a5e4
--- /dev/null
+++ b/content/docs/pt-PT/publishing/modtale.mdx
@@ -0,0 +1,137 @@
+---
+title: Modtale
+description: Complete guide to publishing and managing your Hytale mods on Modtale.
+---
+
+# Publishing Your Mod on Modtale
+
+[Modtale](https://modtale.net) is the Hytale Community Repository for discovering mods, asset packs, worlds, and modpacks.
+
+This guide will walk you through the complete process of publishing your mod.
+
+## Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file of your plugin, or `.zip` of your asset pack
+- A description of your mod's features
+
+We also recommended:
+
+- High-quality screenshots or images of your mod in action
+- A clear logo or icon (recommended size: 512x512px)
+- Any dependencies or requirements documented
+
+## Step-by-Step Publishing Process
+
+### 1. Account Setup
+
+Sign in to [Modtale](https://modtale.net) using your preferred method. If you don't have an account, create one first.
+
+### 2. Start Creating
+
+Click on the **"Create"** button in the navigation bar or go directly to the [upload page](https://modtale.net/upload).
+
+### 3. Choose Content Type
+
+Select the appropriate content type for your submission:
+
+- **Server Plugins** - For Hytale server-side plugins and modifications
+- **Data Assets** - For custom data packs, loot tables, and other data-driven content
+- **Art Assets** - For texture packs, models, and other artistic content
+- **Worlds** - For custom Hytale worlds
+- **Modpacks** - For curated collections of mods and assets
+
+![Content Type Selection](/assets/guides/modtale_type.png)
+
+### 4. Basic Information
+
+Fill in the essential details:
+
+- **Name**: Choose a clear, descriptive name for your mod
+- **Summary**: Write a brief description (1-2 sentences, 250 char max) that explains what your mod does
+
+![Project Title and Description](/assets/guides/modtale_title.png)
+
+### 5. Project Configuration
+
+Now you're on your project's management page. Here you can:
+
+#### Upload Files
+
+Navigate to the **"Files"** tab and upload your `.jar` or `.zip` file:
+
+- Drag and drop your file or use the upload button
+- Add version notes describing changes and new features
+- Mark release type (Release, Beta, Alpha)
+
+![File Upload Interface](/assets/guides/modtale_upload.png)
+
+#### Customize Your Project
+
+- **Logo**: Upload a high-quality logo (512x512 recommended)
+- **Banner**: Upload a banner for your page (1920x640 recommended)
+- **Screenshots**: Add multiple screenshots showing your mod in action
+- **Description**: Write a comprehensive description using Markdown formatting
+- **Links**: Add links to your source code, Discord server, or documentation
+- **Tags**: Add relevant tags to help users find your mod
+- **License**: Indicate what license your mod uses from a selection of common licenses, or use a custom license
+
+## Best Practices
+
+### Documentation
+
+<Callout type="info">
+  Always include comprehensive documentation in your mod description. Users should understand what your mod does, how to use it, and any special requirements.
+</Callout>
+
+### Version Notes
+
+When uploading new versions:
+
+- You must adhere to SemVer
+- Clearly document all changes and new features
+- Include bug fixes and known issues
+- Mention any breaking changes or migration steps
+- List new dependencies or requirement changes
+
+### Visual Appeal
+
+- Use high-quality screenshots that showcase your mod's features in the gallery
+- Create an eye-catching logo that represents your mod
+- Consider adding a banner image for your project page
+
+### Community Engagement
+
+- Respond to comments and feedback promptly
+- Consider creating a Discord server for community support
+- Regularly update your mod based on user feedback
+
+## After Publishing
+
+### Automated updates
+
+- You can configure your project to automatically upload new versions using Github Actions, Gradle, Maven, or Go. See examples [here](https://github.com/Modtale/modtale-example)
+
+### Monitoring Your Project
+
+- Check the analytics to see download statistics
+- Monitor comments and reviews
+- Keep track of bug reports and feature requests
+
+### Marketing Your Mod
+
+- Share your mod on relevant Hytale communities
+- Create showcase videos or tutorials
+- Engage with other modders and creators
+
+<Callout type="warning">
+  Remember to keep your mod updated for new Hytale versions and maintain compatibility with Hytale's modding framework to maximize your audience reach.
+</Callout>
+
+## Getting Help
+
+If you encounter any issues during the publishing process:
+
+- Join their Discord community for support
+- Contact the Modtale team directly through their support channels
diff --git a/content/docs/pt-PT/quick-start.mdx b/content/docs/pt-PT/quick-start.mdx
index 853353b5..18ab3e2d 100644
--- a/content/docs/pt-PT/quick-start.mdx
+++ b/content/docs/pt-PT/quick-start.mdx
@@ -3,4 +3,9 @@ title: Quick Start
 description: Setting up a standard Hytale project.
 ---
 
-Lorem Ipsum Dolor Sit Amet
+Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+
+* [Java Basics](./guides/java-basics/00-introduction)
+* [Setting up your dev environment](./guides/plugin/setting-up-env)
+* [Entity Component System (ECS)](./guides/ecs)
+* [Publishing your mod](./guides/publishing)
diff --git a/content/docs/pt-PT/server/entities.mdx b/content/docs/pt-PT/server/entities.mdx
new file mode 100644
index 00000000..872f3fa4
--- /dev/null
+++ b/content/docs/pt-PT/server/entities.mdx
@@ -0,0 +1,441 @@
+---
+title: Entities
+description: List of all Entities in Hytale
+icon: List
+full: true
+---
+
+This page contains a list of all Entities available to be used as a key in the AssetMap.
+
+- Antelope
+- Archaeopteryx
+- Armadillo
+- Arrow_Crossbow_Signature
+- Arrow_Crude
+- Arrow_Fire
+- Arrow_Frost
+- Arrow_Iron
+- Arrow_Ricochet
+- Arrow_Ricochet_Signature
+- Arrow_Shortbow_Signature
+- Arrow_Vamp
+- Arrow_Vamp_Signature
+- Axe_Bone
+- Axe_Stone_Trork
+- Bat
+- Bat_Ice
+- Bear_Grizzly
+- Bear_Polar
+- Bison
+- Bison_Calf
+- Bluebird
+- Bluegill
+- Boar
+- Boar_Piglet
+- Boat
+- Bomb
+- Bomb_Fire_Goblin
+- Bomb_Fire_Goblin_Dud
+- Bomb_Large_Fire_Goblin
+- Bomb_Popberry
+- Bomb_Potion_Poison
+- Boy_Trail
+- Bramblekin
+- Bramblekin_Shaman
+- Bullet_Blunderbuss
+- Bunny
+- Cactee
+- Cactee_Spike
+- Calf
+- Camel
+- Camel_Calf
+- Cat
+- Catfish
+- Chick
+- Chick_Desert
+- Chicken
+- Chicken_Desert
+- Chicken_Undead
+- Clownfish
+- Corgi
+- Cow
+- Cow_Undead
+- Crab
+- Crawler_Void
+- Crocodile
+- Crossbow_Turret
+- Crossbow_Turret_Item_Projectile
+- Crow
+- Dagger_Adamantite
+- Dagger_Bone
+- Dagger_Bronze
+- Dagger_Bronze_Ancient
+- Dagger_Cobalt
+- Dagger_Copper
+- Dagger_Crude
+- Dagger_Doomed
+- Dagger_Fang_Doomed
+- Dagger_Iron
+- Dagger_Mithril
+- Dagger_Onyxium
+- Dagger_Stone_Trork
+- Dagger_Thorium
+- Debug
+- Deer_Doe
+- Deployable_Fire_Trap
+- Deployable_Fire_Trap_Preview
+- Dog
+- Dragon_Fire
+- Dragon_Frost
+- Dragon_Void
+- Duck
+- Eel_Moray
+- Egg
+- Emberwulf
+- Eye_Void
+- Eye_Void_Blast
+- Fen_Stalker
+- Feran
+- Feran_Burrower
+- Feran_Civilian
+- Feran_Cub
+- Feran_Longtooth
+- Feran_Sharptooth
+- Feran_Windwalker
+- Feran_Windwalker_Wind_Burst
+- Feran_Windwalker_Wind_Vortex
+- Finch_Green
+- Fireball
+- Flamingo
+- Fox
+- Frog_Blue
+- Frog_Green
+- Frog_Orange
+- Frostgill
+- Gecko
+- Ghoul
+- Goat
+- Goat_Kid
+- Goblin
+- Goblin_Boss
+- Goblin_Duke
+- Goblin_Duke_Large
+- Goblin_Hermit
+- Goblin_Lobber
+- Goblin_Miner
+- Goblin_Ogre
+- Goblin_Scrapper
+- Goblin_Thief
+- Golem_Crystal_Earth
+- Golem_Crystal_Flame
+- Golem_Crystal_Frost
+- Golem_Crystal_Sand
+- Golem_Crystal_Thunder
+- Golem_Firesteel
+- Golem_Guardian_Void
+- Grooble
+- Hatworm
+- Hawk
+- Healing_Totem
+- Healing_Totem_Projectile
+- Hedera
+- Horse
+- Horse_Foal
+- Horse_Skeleton
+- Horse_Skeleton_Armored
+- Hound_Bleached
+- Hyena
+- Ice_Ball
+- Ice_Bolt
+- Ingredient_Poop
+- Jellyfish_Blue
+- Jellyfish_Cyan
+- Jellyfish_Green
+- Jellyfish_Man_Of_War
+- Jellyfish_Red
+- Jellyfish_Yellow
+- Klops
+- Klops_Gentleman
+- Klops_Merchant
+- Klops_Miner
+- Kunai
+- Kweebec_Rootling
+- Kweebec_Sapling
+- Kweebec_Sapling_Brown
+- Kweebec_Sapling_Christmas_Blue
+- Kweebec_Sapling_Christmas_Green
+- Kweebec_Sapling_Christmas_Pink
+- Kweebec_Sapling_Green
+- Kweebec_Sapling_HardHat
+- Kweebec_Sapling_Orange
+- Kweebec_Sapling_Pink
+- Kweebec_Sapling_Razorleaf
+- Kweebec_Sapling_Red
+- Kweebec_Sapling_Treesinger
+- Kweebec_Sapling_Yellow
+- Kweebec_Seedling
+- Kweebec_Sproutling
+- Kweebec_Sproutling_Blue
+- Kweebec_Sproutling_Lime
+- Lamb
+- Larva_Silk
+- Larva_Void
+- Leopard_Snow
+- Lizard_Sand
+- Lobster
+- Mannequin
+- Meerkat
+- Minecart
+- Minnow
+- Model_Bee_Swarm
+- Model_Deer_Stag
+- Molerat
+- Moose_Bull
+- Moose_Cow
+- Mosshorn
+- Mosshorn_Plain
+- Mouflon
+- Mouflon_Lamb
+- Mouse
+- Mushee
+- NPC_Elf
+- NPC_Path_Marker
+- NPC_Santa
+- NPC_Sound_Shoe
+- NPC_Spawn_Marker
+- Necromancer_Void
+- Objective_Location_Marker
+- Outlander
+- Outlander_Berserker
+- Outlander_Brute
+- Outlander_Cultist
+- Outlander_Hunter
+- Outlander_Marauder
+- Outlander_Peon
+- Outlander_Priest
+- Outlander_Sorcerer
+- Outlander_Stalker
+- Owl_Brown
+- Owl_Snow
+- Parrot
+- Penguin
+- Pig
+- Pig_Undead
+- Pig_Wild
+- Pigeon
+- Piglet
+- Piglet_Wild
+- Pike
+- Piranha
+- Piranha_Black
+- Player
+- PlayerTestModel_G
+- PlayerTestModel_V
+- Projectile
+- Pterodactyl
+- Pufferfish
+- Rabbit
+- Ram
+- Ram_Lamb
+- Raptor_Cave
+- Rat
+- Raven
+- Reindeer_Christmas
+- Rex_Cave
+- Rubble_Aqua
+- Rubble_Basalt
+- Rubble_Calcite
+- Rubble_Default
+- Rubble_Ice
+- Rubble_Marble
+- Rubble_Quartzite
+- Rubble_Sandstone
+- Rubble_Sandstone_Red
+- Rubble_Sandstone_White
+- Rubble_Shale
+- Rubble_Slate
+- Rubble_Stone
+- Rubble_Stone_Mossy
+- Rubble_Volcanic
+- Salmon
+- Saurian
+- Saurian_Hunter
+- Saurian_Rogue
+- Saurian_Warrior
+- Scarak_Broodmother
+- Scarak_Broodmother_Young
+- Scarak_Defender
+- Scarak_Fighter
+- Scarak_Fighter_Royal_Guard
+- Scarak_Louse
+- Scarak_Seeker
+- Scarak_Seeker_Spitball
+- Scorpion
+- Shadow_Knight
+- Shark_Hammerhead
+- Sheep
+- Shellfish_Lava
+- Showcase_Cobalt_Gear
+- Showcase_Copper_Gear
+- Showcase_Iron_Gear
+- Showcase_Iron_TargetDummy_1
+- Showcase_Mannequin_Heal
+- Showcase_Mannequin_Inv_Portal
+- Showcase_Mannequin_Inv_Sphere
+- Showcase_Mannequin_Lightning
+- Showcase_Mannequin_Sitting
+- Showcase_Onyxium_Gear
+- Showcase_Prisma_Gear
+- Showcase_Skeleton_Assasin
+- Showcase_Skeleton_Dead
+- Showcase_Skeleton_Guard
+- Showcase_Skeleton_Tank
+- Showcase_Wooden_Gear
+- Skeleton
+- Skeleton_Archer
+- Skeleton_Archmage
+- Skeleton_Burnt_Alchemist
+- Skeleton_Burnt_Archer
+- Skeleton_Burnt_Gunner
+- Skeleton_Burnt_Knight
+- Skeleton_Burnt_Lancer
+- Skeleton_Burnt_Praetorian
+- Skeleton_Burnt_Soldier
+- Skeleton_Burnt_Wizard
+- Skeleton_Fighter
+- Skeleton_Frost_Archer
+- Skeleton_Frost_Archmage
+- Skeleton_Frost_Fighter
+- Skeleton_Frost_Knight
+- Skeleton_Frost_Mage
+- Skeleton_Frost_Ranger
+- Skeleton_Frost_Scout
+- Skeleton_Frost_Soldier
+- Skeleton_Incandescent_Fighter
+- Skeleton_Incandescent_Footman
+- Skeleton_Incandescent_Head
+- Skeleton_Incandescent_Mage
+- Skeleton_Knight
+- Skeleton_Mage
+- Skeleton_Mage_Corruption_Orb
+- Skeleton_Pirate_Captain
+- Skeleton_Pirate_Gunner
+- Skeleton_Pirate_Striker
+- Skeleton_Ranger
+- Skeleton_Sand_Archer
+- Skeleton_Sand_Archmage
+- Skeleton_Sand_Assassin
+- Skeleton_Sand_Guard
+- Skeleton_Sand_Mage
+- Skeleton_Sand_Ranger
+- Skeleton_Sand_Scout
+- Skeleton_Sand_Soldier
+- Skeleton_Scout
+- Skeleton_Soldier
+- Skrill
+- Skrill_Chick
+- Slothian
+- Slothian_Elder
+- Slothian_Kid
+- Slothian_Monk
+- Slothian_Scout
+- Slothian_Villager
+- Slothian_Warrior
+- Slowness_Totem
+- Slowness_Totem_Projectile
+- Slug_Magma
+- Snail_Frost
+- Snail_Magma
+- Snake_Cobra
+- Snake_Marsh
+- Snake_Rattle
+- Snapdragon
+- Snapjaw
+- Spark_Living
+- Sparrow
+- Spawn_Void
+- Spear_Adamantite
+- Spear_Adamantite_Saurian
+- Spear_Bone
+- Spear_Bronze
+- Spear_Cobalt
+- Spear_Copper
+- Spear_Crude
+- Spear_Double_Incandescent
+- Spear_Iron
+- Spear_Leaf
+- Spear_Mithril
+- Spear_Onyxium
+- Spear_Scrap
+- Spear_Stone_Trork
+- Spear_Thorium
+- Spear_Tribal
+- Spectre_Void
+- Spider
+- Spider_Cave
+- Spirit_Ember
+- Spirit_Frost
+- Spirit_Root
+- Spirit_Thunder
+- Squirrel
+- Swarm_Bees
+- Sword_Charged_Test
+- Tang_Blue
+- Tang_Chevron
+- Tang_Lemon_Peel
+- Tang_Sailfin
+- Tank
+- Temple_Mithril_Guard
+- Test_Platform
+- Tetrabird
+- Tiger_Sabertooth
+- Toad_Rhino
+- Toad_Rhino_Magma
+- Tornado
+- Tortoise
+- Trash
+- Trillodon
+- Trilobite
+- Trilobite_Black
+- Trork
+- Trork_Brawler
+- Trork_Chieftain
+- Trork_Christmas
+- Trork_Doctor_Witch
+- Trork_Guard
+- Trork_Hunter
+- Trork_Mauler
+- Trork_Sentry
+- Trork_Shaman
+- Trork_Warrior
+- Trout_Rainbow
+- Tuluk
+- Tuluk_Fisherman
+- Turkey
+- Turkey_Chick
+- Vulture
+- Warp
+- Warrior_Quest
+- Warthog
+- Warthog_Piglet
+- Werewolf
+- Whale_Humpback
+- Wolf_Black
+- Wolf_Outlander_Priest
+- Wolf_Outlander_Sorcerer
+- Wolf_Trork_Hunter
+- Wolf_Trork_Shaman
+- Wolf_White
+- Woodpecker
+- Wraith
+- Wraith_Lantern
+- Wurmling_Frost
+- Yeti
+- Zombie
+- Zombie_Aberrant
+- Zombie_Aberrant_Big
+- Zombie_Aberrant_Small
+- Zombie_Burnt
+- Zombie_Frost
+- Zombie_Sand
+- Zombie_Werewolf
diff --git a/content/docs/pt-PT/server/events.mdx b/content/docs/pt-PT/server/events.mdx
new file mode 100644
index 00000000..ca7ed28f
--- /dev/null
+++ b/content/docs/pt-PT/server/events.mdx
@@ -0,0 +1,104 @@
+---
+title: Events
+description: List of all events in Hytale
+icon: List
+full: true
+---
+
+## IEvent
+
+- AddPlayerToWorldEvent
+- AllNPCsLoadedEvent
+- AllWorldsLoadedEvent
+- AssetMonitorEvent
+  - AssetStoreMonitorEvent
+  - CommonAssetMonitorEvent
+- AssetPackRegisterEvent
+- AssetPackUnregisterEvent
+- AssetStoreEvent
+  - RegisterAssetStoreEvent
+  - RemoveAssetStoreEvent
+- AssetsEvent
+  - GenerateAssetsEvent
+  - LoadedAssetsEvent
+  - RemovedAssetsEvent
+- BootEvent
+- ChunkEvent
+  - ChunkPreLoadProcessEvent
+- DrainPlayerFromWorldEvent
+- EditorClientEvent
+  - AssetEditorActivateButtonEvent
+  - AssetEditorAssetCreatedEvent
+  - AssetEditorClientDisconnectEvent
+  - AssetEditorSelectAssetEvent
+  - AssetEditorUpdateWeatherPreviewLockEvent
+- EntityEvent
+  - EntityRemoveEvent
+  - LivingEntityInventoryChangeEvent
+- GenerateDefaultLanguageEvent
+- GenerateSchemaEvent
+- GenerateServerStateEvent
+- ItemContainerChangeEvent
+- ~~LivingEntityUseBlockEvent~~ DEPRECATED
+- LoadAssetEvent
+- LoadedNPCEvent
+- MessagesUpdated
+- PlayerConnectEvent
+- PlayerEvent
+  - ~~PlayerCraftEvent~~ DEPRECATED
+  - ~~PlayerInteractEvent~~ DEPRECATED
+  - PlayerMouseButtonEvent
+  - PlayerMouseMotionEvent
+  - PlayerReadyEvent
+  - RemovePlayerFromWorldEvent
+- PlayerRefEvent
+  - PlayerDisconnectEvent
+- PlayerSetupConnectEvent
+- PlayerSetupDisconnectEvent
+- PluginEvent
+  - PluginSetupEvent
+- ~~PrepareUniverseEvent~~ DEPRECATED
+- ShutdownEvent
+- SingleplayerRequestAccessEvent
+- TreasureChestOpeningEvent
+- WindowCloseEvent
+- WorldEvent
+  - AddWorldEvent
+  - RemoveWorldEvent
+  - StartWorldEvent
+- WorldPathChangedEvent
+
+## IAsyncEvent
+
+- AssetEditorFetchAutoCompleteDataEvent
+- AssetEditorRequestDataSetEvent
+- PlayerChatEvent
+- SendCommonAssetsEvent
+
+## EcsEvent
+
+- CancellableEcsEvent
+  - BreakBlockEvent
+  - ChangeGameModeEvent
+  - ChunkSaveEvent
+  - ChunkUnloadEvent
+  - CraftRecipeEvent
+    - Post
+    - Pre
+  - Damage
+  - DamageBlockEvent
+  - DropItemEvent
+    - Drop
+    - PlayerRequest
+  - InteractivelyPickupItemEvent
+  - PlaceBlockEvent
+  - PrefabPasteEvent
+  - SwitchActiveSlotEvent
+- DiscoverInstanceEvent
+  - Display
+- DiscoverZoneEvent
+  - Display
+- MoonPhaseChangeEvent
+- UseBlockEvent
+  - Post
+  - Pre
diff --git a/content/docs/pt-PT/server/sounds.mdx b/content/docs/pt-PT/server/sounds.mdx
new file mode 100644
index 00000000..5b54a035
--- /dev/null
+++ b/content/docs/pt-PT/server/sounds.mdx
@@ -0,0 +1,1162 @@
+---
+title: Sounds
+description: List of all Sounds in Hytale
+icon: List
+full: true
+---
+
+This page contains a list of all Sounds available to be used as a key in the AssetMap.
+
+- SFX_Alchemy_Bench_Close
+- SFX_Alchemy_Bench_Craft
+- SFX_Alchemy_Bench_Open
+- SFX_Antelope_Alerted
+- SFX_Antelope_Death
+- SFX_Antelope_Hurt
+- SFX_Antelope_Run
+- SFX_Antelope_Walk
+- SFX_Arcane_Workbench_Close_Local
+- SFX_Arcane_Workbench_Craft
+- SFX_Arcane_Workbench_Open_Local
+- SFX_Armour_Bench_Close
+- SFX_Armour_Bench_Craft
+- SFX_Armour_Bench_Open
+- SFX_Arrow_Fire_Hit
+- SFX_Arrow_Fire_Miss
+- SFX_Arrow_Frost_Hit
+- SFX_Arrow_Frost_Miss
+- SFX_Arrow_FullCharge_Hit
+- SFX_Arrow_FullCharge_Miss
+- SFX_Arrow_HalfCharge_Hit
+- SFX_Arrow_HalfCharge_Miss
+- SFX_Arrow_NoCharge_Hit
+- SFX_Arrow_NoCharge_Miss
+- SFX_Arrow_Whistle
+- SFX_Attn_Loud
+- SFX_Attn_Moderate
+- SFX_Attn_Quiet
+- SFX_Attn_VeryLoud
+- SFX_Attn_VeryQuiet
+- SFX_Avatar_Powers_Disable
+- SFX_Avatar_Powers_Disable_Local
+- SFX_Avatar_Powers_Enable
+- SFX_Avatar_Powers_Enable_Local
+- SFX_Axe_Crude_Impact
+- SFX_Axe_Crude_Swing
+- SFX_Axe_Iron_Impact
+- SFX_Axe_Iron_Swing
+- SFX_Axe_Special_Impact
+- SFX_Axe_Special_Swing
+- SFX_Axe_Stone_Trork_Hit
+- SFX_Axe_Stone_Trork_Miss
+- SFX_Bat_Alerted
+- SFX_Bat_Death
+- SFX_Bat_Hurt
+- SFX_Battleaxe_T1_Block_Impact
+- SFX_Battleaxe_T1_Impact
+- SFX_Battleaxe_T1_Launch
+- SFX_Battleaxe_T1_Launch_Local
+- SFX_Battleaxe_T1_Raise
+- SFX_Battleaxe_T1_Raise_Local
+- SFX_Battleaxe_T1_Shove
+- SFX_Battleaxe_T1_Shove_Local
+- SFX_Battleaxe_T1_Swing
+- SFX_Battleaxe_T1_Swing_Charged
+- SFX_Battleaxe_T1_Swing_Charged_Local
+- SFX_Battleaxe_T1_Swing_Down_Local
+- SFX_Battleaxe_T1_Swing_LR_Local
+- SFX_Battleaxe_T1_Swing_RL_Local
+- SFX_Battleaxe_T2_Impact
+- SFX_Battleaxe_T2_Raise
+- SFX_Battleaxe_T2_Raise_Local
+- SFX_Battleaxe_T2_Signature_End
+- SFX_Battleaxe_T2_Signature_End_Local
+- SFX_Battleaxe_T2_Signature_Swing
+- SFX_Battleaxe_T2_Signature_Swing_Local
+- SFX_Battleaxe_T2_Swing
+- SFX_Battleaxe_T2_Swing_Charged
+- SFX_Battleaxe_T2_Swing_Charged_Local
+- SFX_Battleaxe_T2_Swing_Down_Local
+- SFX_Battleaxe_T2_Swing_LR_Local
+- SFX_Battleaxe_T2_Swing_RL_Local
+- SFX_Bear_Grizzly_Alerted
+- SFX_Bear_Grizzly_Attack
+- SFX_Bear_Grizzly_Death
+- SFX_Bear_Grizzly_Hurt
+- SFX_Bear_Grizzly_Run
+- SFX_Bear_Grizzly_Sleep
+- SFX_Bear_Walk
+- SFX_Bench_Placeholder
+- SFX_Bison_Alerted
+- SFX_Bison_Death
+- SFX_Bison_Hurt
+- SFX_Bison_Idle
+- SFX_Bison_Run
+- SFX_Bison_Walk
+- SFX_Blunderbuss_Bullet_WhizBy
+- SFX_Blunderbuss_Fire
+- SFX_Blunderbuss_Fire_Local
+- SFX_Blunderbuss_Hit
+- SFX_Blunderbuss_Load
+- SFX_Blunderbuss_Load_Local
+- SFX_Blunderbuss_Miss
+- SFX_Blunderbuss_No_Ammo
+- SFX_Boar_Alerted
+- SFX_Boar_Death
+- SFX_Boar_Hurt
+- SFX_Boar_Run
+- SFX_Boar_Sleep
+- SFX_Boar_Walk
+- SFX_Bomb_Fire_Goblin_Bounce
+- SFX_Bomb_Fire_Goblin_Death
+- SFX_Bomb_Fire_Goblin_Hit
+- SFX_Bomb_Fire_Goblin_Miss
+- SFX_Bomb_Fuse
+- SFX_Bone_Break
+- SFX_Bone_Build
+- SFX_Bone_Hit
+- SFX_Bone_Land
+- SFX_Bone_Walk
+- SFX_Bow_No_Ammo
+- SFX_Bow_T1_Block_Impact
+- SFX_Bow_T1_Draw
+- SFX_Bow_T1_Draw_Local
+- SFX_Bow_T1_Raise
+- SFX_Bow_T1_Raise_Local
+- SFX_Bow_T1_Shoot
+- SFX_Bow_T1_Shoot_Local
+- SFX_Bow_T1_Swing
+- SFX_Bow_T1_Swing_Local
+- SFX_Bow_T2_Draw
+- SFX_Bow_T2_Draw_Local
+- SFX_Bow_T2_Shoot
+- SFX_Bow_T2_Shoot_Local
+- SFX_Bow_T2_Signature_Loop
+- SFX_Bow_T2_Signature_Loop_Local
+- SFX_Bow_T2_Signature_Nock
+- SFX_Bow_T2_Signature_Nock_Local
+- SFX_Bow_T2_Signature_Shoot
+- SFX_Bow_T2_Signature_Shoot_Local
+- SFX_Bramble_MoveIn
+- SFX_Branch_Break
+- SFX_Branch_Build
+- SFX_Branch_Hit
+- SFX_Branch_Land
+- SFX_Branch_Walk
+- SFX_Brazier_Break
+- SFX_Brazier_Build
+- SFX_Bunny_Alerted
+- SFX_Bunny_Death
+- SFX_Bunny_Hurt
+- SFX_Bush_Break
+- SFX_Bush_Hit
+- SFX_Bush_MoveIn
+- SFX_Cactus_Break
+- SFX_Cactus_Hit
+- SFX_Cactus_Large_Hit
+- SFX_Cactus_Small_Break
+- SFX_Cactus_Small_Hit
+- SFX_Calf_Hurt
+- SFX_Calf_Run
+- SFX_Calf_Walk
+- SFX_Camel_Alerted
+- SFX_Camel_Death
+- SFX_Camel_Hurt
+- SFX_Camel_Laydown
+- SFX_Camel_Run
+- SFX_Camel_Sleep
+- SFX_Camel_Wake
+- SFX_Camel_Walk
+- SFX_Campfire_Break
+- SFX_Campfire_Build
+- SFX_Campfire_Close_Local
+- SFX_Campfire_Default_Loop
+- SFX_Campfire_Open_Local
+- SFX_Campfire_Processing
+- SFX_Campfire_Processing_End
+- SFX_Campfire_Processing_Failed
+- SFX_Candle_Default_Loop
+- SFX_Candle_Off
+- SFX_Capture_Crate_Capture_Fail_Local
+- SFX_Capture_Crate_Capture_Succeed
+- SFX_Capture_Crate_Capture_Succeed_Local
+- SFX_Capture_Crate_Spawn_Fail_Local
+- SFX_Capture_Crate_Spawn_Succeed
+- SFX_Cauldron_Bubbling
+- SFX_Cauldron_Bubbling_Small
+- SFX_Chest_Legendary_Close_Player
+- SFX_Chest_Legendary_FirstOpen_Player
+- SFX_Chest_Legendary_Loop
+- SFX_Chest_Legendary_Open
+- SFX_Chest_Wooden_Close
+- SFX_Chest_Wooden_Open
+- SFX_Chest_Wooden_Open_Player
+- SFX_Chick_Alerted
+- SFX_Chick_Death
+- SFX_Chick_Hurt
+- SFX_Chicken_Alerted
+- SFX_Chicken_Death
+- SFX_Chicken_Flee
+- SFX_Chicken_Hurt
+- SFX_Chicken_Run
+- SFX_Chicken_Walk
+- SFX_Clay_Pot_Large_Break
+- SFX_Clay_Pot_Large_Build
+- SFX_Clay_Pot_Large_Hit
+- SFX_Clay_Pot_Large_Walk
+- SFX_Clay_Pot_Small_Break
+- SFX_Clay_Pot_Small_Build
+- SFX_Clay_Pot_Small_Hit
+- SFX_Clay_Pot_Small_Walk
+- SFX_Cloth_Break
+- SFX_Cloth_Build
+- SFX_Cloth_Hit
+- SFX_Cloth_Land
+- SFX_Cloth_Walk
+- SFX_Club_Meat_Impact
+- SFX_Club_Meat_Swing
+- SFX_Club_Special_Impact
+- SFX_Club_Special_Swing
+- SFX_Club_Steel_Impact
+- SFX_Club_Steel_Swing
+- SFX_Club_Wood_Impact
+- SFX_Club_Wood_Swing
+- SFX_Cocoon_Active
+- SFX_Cocoon_Break
+- SFX_Cocoon_Build
+- SFX_Cocoon_Hit
+- SFX_Cocoon_Walk
+- SFX_Coins_Land
+- SFX_Coins_Walk
+- SFX_Consume_Bread
+- SFX_Consume_Bread_Local
+- SFX_Cow_Alerted
+- SFX_Cow_Death
+- SFX_Cow_Hurt
+- SFX_Cow_Idle
+- SFX_Cow_Run
+- SFX_Cow_Sleep
+- SFX_Cow_Walk
+- SFX_Crawler_Void_Alerted
+- SFX_Crawler_Void_Alerted_02
+- SFX_Crawler_Void_Death
+- SFX_Crawler_Void_Despawn
+- SFX_Crawler_Void_Hurt
+- SFX_Crawler_Void_Run
+- SFX_Crawler_Void_Sleep
+- SFX_Crawler_Void_Spawn
+- SFX_Crawler_Void_Spawn_02
+- SFX_Crawler_Void_Walk
+- SFX_Creative_Play_Add_Mask
+- SFX_Creative_Play_Brush_Erase
+- SFX_Creative_Play_Brush_Mode
+- SFX_Creative_Play_Brush_Paint_Base
+- SFX_Creative_Play_Brush_Paint_Idle_Layer
+- SFX_Creative_Play_Brush_Paint_Move_Layer
+- SFX_Creative_Play_Brush_Shape
+- SFX_Creative_Play_Brush_Stamp
+- SFX_Creative_Play_Error
+- SFX_Creative_Play_Eyedropper_Select
+- SFX_Creative_Play_Paste
+- SFX_Creative_Play_Selection_Drag
+- SFX_Creative_Play_Selection_Place
+- SFX_Creative_Play_Selection_Scale
+- SFX_Creative_Play_Selection_Widget
+- SFX_Creative_Play_Set_Mask
+- SFX_Crocodile_Alerted
+- SFX_Crocodile_Death
+- SFX_Crocodile_Hurt
+- SFX_Crops_Grow
+- SFX_Crops_Grow_Stage_Complete
+- SFX_Crow_Death
+- SFX_Crow_Hurt
+- SFX_Crystal_Break
+- SFX_Crystal_Build
+- SFX_Crystal_Hit
+- SFX_Crystal_Walk
+- SFX_Daggers_T1_Guard
+- SFX_Daggers_T1_Guard_Local
+- SFX_Daggers_T1_Pounce
+- SFX_Daggers_T1_Pounce_Local
+- SFX_Daggers_T1_Slash_Impact
+- SFX_Daggers_T1_Stab_Double_Impact
+- SFX_Daggers_T1_Stab_Impact
+- SFX_Daggers_T1_Stab_Left_Local
+- SFX_Daggers_T1_Stab_Retreat
+- SFX_Daggers_T1_Stab_Retreat_Local
+- SFX_Daggers_T1_Stab_Right_Local
+- SFX_Daggers_T1_Swing
+- SFX_Daggers_T1_Swing_Double
+- SFX_Daggers_T1_Swing_Double_Local
+- SFX_Daggers_T1_Swing_LR_Local
+- SFX_Daggers_T1_Swing_RL_Local
+- SFX_Daggers_T2_Guard
+- SFX_Daggers_T2_Guard_Local
+- SFX_Daggers_T2_Signature_P1
+- SFX_Daggers_T2_Signature_P1_Local
+- SFX_Daggers_T2_Signature_P2
+- SFX_Daggers_T2_Signature_P2_Local
+- SFX_Daggers_T2_Signature_P3
+- SFX_Daggers_T2_Signature_P3_Local
+- SFX_Daggers_T2_Slash_Impact
+- SFX_Daggers_T2_Stab_Double_Impact
+- SFX_Daggers_T2_Stab_Impact
+- SFX_Daggers_T2_Stab_Left_Local
+- SFX_Daggers_T2_Stab_Retreat
+- SFX_Daggers_T2_Stab_Retreat_Local
+- SFX_Daggers_T2_Stab_Right_Local
+- SFX_Daggers_T2_Swing
+- SFX_Daggers_T2_Swing_Double
+- SFX_Daggers_T2_Swing_Double_Local
+- SFX_Daggers_T2_Swing_LR_Local
+- SFX_Daggers_T2_Swing_RL_Local
+- SFX_Deer_Doe_Alerted
+- SFX_Deer_Doe_Death
+- SFX_Deer_Doe_Hurt
+- SFX_Deer_Doe_Run
+- SFX_Deer_Doe_Sleep
+- SFX_Deer_Stag_Alerted
+- SFX_Deer_Stag_Death
+- SFX_Deer_Stag_Hurt
+- SFX_Deer_Stag_Roar
+- SFX_Deer_Stag_Run
+- SFX_Deer_Stag_Sleep
+- SFX_Deer_Walk
+- SFX_Default_Break
+- SFX_Default_Build
+- SFX_Default_Clone
+- SFX_Default_Harvest
+- SFX_Default_Walk
+- SFX_Deployable_Totem_Heal_Despawn
+- SFX_Deployable_Totem_Heal_Effect_Local
+- SFX_Deployable_Totem_Heal_Spawn
+- SFX_Deployable_Totem_Slowing_Despawn
+- SFX_Deployable_Totem_Slowing_Effect_Local
+- SFX_Deployable_Totem_Slowing_Spawn
+- SFX_Dirt_Break
+- SFX_Dirt_Build
+- SFX_Dirt_Clone
+- SFX_Dirt_Hit
+- SFX_Dirt_Land
+- SFX_Dirt_Walk
+- SFX_Discovery_Z1_Medium
+- SFX_Discovery_Z1_Short
+- SFX_Discovery_Z2_Medium
+- SFX_Discovery_Z2_Short
+- SFX_Discovery_Z3_Medium
+- SFX_Discovery_Z3_Short
+- SFX_Discovery_Z4_Medium
+- SFX_Discovery_Z4_Short
+- SFX_Divine_Respawn
+- SFX_Door_Ancient_Close
+- SFX_Door_Ancient_Open
+- SFX_Door_Crude_Close
+- SFX_Door_Crude_Open
+- SFX_Door_Desert_Close
+- SFX_Door_Desert_Open
+- SFX_Door_Jungle_Close
+- SFX_Door_Jungle_Open
+- SFX_Door_Lumberjack_Close
+- SFX_Door_Lumberjack_Open
+- SFX_Door_Temple_Dark_Close
+- SFX_Door_Temple_Dark_Open
+- SFX_Door_Temple_Light_Close
+- SFX_Door_Temple_Light_Open
+- SFX_Door_Wooden_Close
+- SFX_Door_Wooden_Open
+- SFX_Drag_Armor_Cloth
+- SFX_Drag_Armor_Heavy
+- SFX_Drag_Armor_Leather
+- SFX_Drag_Blocks_Gravel
+- SFX_Drag_Blocks_Soft
+- SFX_Drag_Blocks_Splatty
+- SFX_Drag_Blocks_Stone
+- SFX_Drag_Blocks_Wood
+- SFX_Drag_Item_Default
+- SFX_Drag_Items_Bones
+- SFX_Drag_Items_Chest
+- SFX_Drag_Items_Clay
+- SFX_Drag_Items_Cloth
+- SFX_Drag_Items_Foliage
+- SFX_Drag_Items_Gadget
+- SFX_Drag_Items_Gems
+- SFX_Drag_Items_Ingots
+- SFX_Drag_Items_Leather
+- SFX_Drag_Items_Metal
+- SFX_Drag_Items_Paper
+- SFX_Drag_Items_Potion
+- SFX_Drag_Items_Seeds
+- SFX_Drag_Items_Shells
+- SFX_Drag_Items_Splatty
+- SFX_Drag_Weapon_Blade_Small
+- SFX_Drag_Weapon_Blunt_Large
+- SFX_Drag_Weapons_Arrows
+- SFX_Drag_Weapons_Blade_Large
+- SFX_Drag_Weapons_Blunt_Small
+- SFX_Drag_Weapons_Books
+- SFX_Drag_Weapons_Shield_Metal
+- SFX_Drag_Weapons_Shield_Wood
+- SFX_Drag_Weapons_Stone_Large
+- SFX_Drag_Weapons_Stone_Small
+- SFX_Drag_Weapons_Wand
+- SFX_Drag_Weapons_Wood
+- SFX_Dragon_Sleep
+- SFX_Drop_Armor_Cloth
+- SFX_Drop_Armor_Heavy
+- SFX_Drop_Armor_Leather
+- SFX_Drop_Blocks_Gravel
+- SFX_Drop_Blocks_Soft
+- SFX_Drop_Blocks_Splatty
+- SFX_Drop_Blocks_Stone
+- SFX_Drop_Blocks_Wood
+- SFX_Drop_Item_Default
+- SFX_Drop_Items_Bones
+- SFX_Drop_Items_Chest
+- SFX_Drop_Items_Clay
+- SFX_Drop_Items_Cloth
+- SFX_Drop_Items_Foliage
+- SFX_Drop_Items_Gadget
+- SFX_Drop_Items_Gems
+- SFX_Drop_Items_Ingots
+- SFX_Drop_Items_Leather
+- SFX_Drop_Items_Metal
+- SFX_Drop_Items_Paper
+- SFX_Drop_Items_Potion
+- SFX_Drop_Items_Seeds
+- SFX_Drop_Items_Shells
+- SFX_Drop_Items_Splatty
+- SFX_Drop_Weapon_Blade_Small
+- SFX_Drop_Weapon_Blunt_Large
+- SFX_Drop_Weapons_Arrows
+- SFX_Drop_Weapons_Blade_Large
+- SFX_Drop_Weapons_Blunt_Small
+- SFX_Drop_Weapons_Books
+- SFX_Drop_Weapons_Shield_Metal
+- SFX_Drop_Weapons_Shield_Wood
+- SFX_Drop_Weapons_Stone_Large
+- SFX_Drop_Weapons_Stone_Small
+- SFX_Drop_Weapons_Wand
+- SFX_Drop_Weapons_Wood
+- SFX_Duck_Alerted
+- SFX_Duck_Death
+- SFX_Duck_Hurt
+- SFX_Duck_Run
+- SFX_Effect_Burn_Local
+- SFX_Effect_Burn_World
+- SFX_Effect_Poison_Local
+- SFX_Effect_Poison_World
+- SFX_Egg_Hit
+- SFX_Egg_Miss
+- SFX_Eggsac_Active
+- SFX_Emberwulf_Alerted
+- SFX_Emberwulf_Attack_Bite
+- SFX_Emberwulf_Death
+- SFX_Emberwulf_Hurt
+- SFX_Emberwulf_Run
+- SFX_Emberwulf_Sleep
+- SFX_Emberwulf_Walk
+- SFX_Emit_Forgotten_Whispers
+- SFX_Emit_Lake_Water
+- SFX_Emit_Temple_Wisps
+- SFX_Emit_Tree_Creak
+- SFX_Emit_Wind_Grass
+- SFX_Emit_Wind_Gusts
+- SFX_Env_Emit_Fluid_Lava
+- SFX_Env_Emit_Fluid_Water
+- SFX_Env_Emit_Fluid_Water_Far
+- SFX_Env_Emit_Geyzer
+- SFX_Eye_Void_Alerted
+- SFX_Eye_Void_Attack_Blast
+- SFX_Eye_Void_Attack_Summon
+- SFX_Eye_Void_Death
+- SFX_Eye_Void_Fly_Movement
+- SFX_Eye_Void_Hurt
+- SFX_Eye_Void_Idle
+- SFX_Fen_Stalker_Alerted
+- SFX_Fen_Stalker_Attack_Swing
+- SFX_Fen_Stalker_Attack_Swipe
+- SFX_Fen_Stalker_Death
+- SFX_Fen_Stalker_Eat
+- SFX_Fen_Stalker_Eat_Finish
+- SFX_Fen_Stalker_Greet
+- SFX_Fen_Stalker_Hurt
+- SFX_Fen_Stalker_Run
+- SFX_Fen_Stalker_Scared
+- SFX_Fen_Stalker_Seek
+- SFX_Fen_Stalker_Sniff
+- SFX_Feran_Death
+- SFX_Fern_Break
+- SFX_Fern_MoveIn
+- SFX_Fireball_Bounce
+- SFX_Fireball_Death
+- SFX_Fireball_Miss
+- SFX_Fish_Death
+- SFX_Fish_Flee
+- SFX_Fish_Hurt
+- SFX_Flail_Charge
+- SFX_Flail_Charge_Local
+- SFX_Flail_Swing
+- SFX_Flail_Swing_Left_Local
+- SFX_Flail_Swing_Right_Local
+- SFX_Flame_Break
+- SFX_Flame_Build
+- SFX_Flame_Default_Loop
+- SFX_Flamingo_Alerted
+- SFX_Flamingo_Death
+- SFX_Flamingo_Fly
+- SFX_Flamingo_Hurt
+- SFX_Forgotten_Temple_Emit_Birds
+- SFX_Forgotten_Temple_Emit_Birds_Interior
+- SFX_Fox_Alerted
+- SFX_Fox_Death
+- SFX_Fox_Hurt
+- SFX_Fox_Run
+- SFX_Fox_Sleep
+- SFX_Frog_Alerted
+- SFX_Frog_Croak
+- SFX_Frog_Death
+- SFX_Frog_Hurt
+- SFX_Frog_Idle
+- SFX_Frog_Run
+- SFX_Furnace_Bench_Close
+- SFX_Furnace_Bench_Open
+- SFX_Furnace_Bench_Processing
+- SFX_Furnace_Bench_Processing_Complete
+- SFX_Furnace_Bench_Processing_End
+- SFX_Furnace_Bench_Processing_Failed
+- SFX_Gecko_Alerted
+- SFX_Gecko_Death
+- SFX_Gecko_Hurt
+- SFX_Gem_Break
+- SFX_Gem_Emit_Loop
+- SFX_Generic_Crafting_Failed
+- SFX_Glass_Break
+- SFX_Global_Weather_Thunder
+- SFX_Goat_Run
+- SFX_Goat_Walk
+- SFX_Goblin_Alerted
+- SFX_Goblin_Death
+- SFX_Goblin_Hurt
+- SFX_Goblin_Lobber_Bomb_Bounce
+- SFX_Goblin_Lobber_Bomb_Death
+- SFX_Goblin_Lobber_Bomb_Hit
+- SFX_Goblin_Lobber_Bomb_Miss
+- SFX_Goblin_Run
+- SFX_Goblin_Search
+- SFX_Golem_Earth_Alerted
+- SFX_Golem_Earth_Death
+- SFX_Golem_Earth_Hurt
+- SFX_Golem_Earth_Laydown
+- SFX_Golem_Earth_Slam
+- SFX_Golem_Earth_Slam_Impact
+- SFX_Golem_Earth_Spin
+- SFX_Golem_Earth_Stomp
+- SFX_Golem_Earth_Stomp_Impact
+- SFX_Golem_Earth_Swing
+- SFX_Golem_Earth_Swing_Impact
+- SFX_Golem_Earth_Wake
+- SFX_Golem_Firesteel_Alerted_01
+- SFX_Golem_Firesteel_Alerted_02
+- SFX_Golem_Firesteel_Death
+- SFX_Golem_Firesteel_Laydown
+- SFX_Golem_Firesteel_Wake
+- SFX_Golem_Frost_Alerted
+- SFX_Golem_Frost_Death
+- SFX_Golem_Frost_Hurt
+- SFX_Golem_Frost_Laydown
+- SFX_Golem_Frost_Slam
+- SFX_Golem_Frost_Slam_Impact
+- SFX_Golem_Frost_Spin
+- SFX_Golem_Frost_Stomp
+- SFX_Golem_Frost_Swing
+- SFX_Golem_Frost_Swing_Impact
+- SFX_Golem_Frost_Wake
+- SFX_Golem_Sand_Alerted
+- SFX_Golem_Sand_Death
+- SFX_Golem_Sand_Hurt
+- SFX_Golem_Sand_Laydown
+- SFX_Golem_Sand_Slam
+- SFX_Golem_Sand_Slam_Impact
+- SFX_Golem_Sand_Spin
+- SFX_Golem_Sand_Stomp
+- SFX_Golem_Sand_Stomp_Impact
+- SFX_Golem_Sand_Swing
+- SFX_Golem_Sand_Swing_Impact
+- SFX_Golem_Sand_Wake
+- SFX_Grass_Break
+- SFX_Grass_Build
+- SFX_Grass_Hit
+- SFX_Grass_Land
+- SFX_Grass_Walk
+- SFX_Gravel_Break
+- SFX_Gravel_Build
+- SFX_Gravel_Hit
+- SFX_Gravel_Land
+- SFX_Gravel_Walk
+- SFX_GunPvP_Assault_Rifle_Bullet_Death
+- SFX_GunPvP_Grenade_Frag_Bounce
+- SFX_GunPvP_Grenade_Frag_Death
+- SFX_GunPvP_Grenade_Frag_Hit
+- SFX_GunPvP_Grenade_Frag_Miss
+- SFX_GunPvP_Handgun_Bullet_Death
+- SFX_Gun_Fire
+- SFX_Hand_Crossbow_T1_Block_Impact
+- SFX_Hand_Crossbow_T1_Raise
+- SFX_Hand_Crossbow_T1_Raise_Local
+- SFX_Hand_Crossbow_T1_Shove
+- SFX_Hand_Crossbow_T1_Shove_Local
+- SFX_Hand_Crossbow_T2_Load
+- SFX_Hand_Crossbow_T2_Load_Local
+- SFX_Hand_Crossbow_T2_Reload_Start
+- SFX_Hand_Crossbow_T2_Reload_Start_Local
+- SFX_Handgun_Fire
+- SFX_Handgun_Fire_Local
+- SFX_Hatchet_T1_Swing_RL_Local
+- SFX_Hatchet_T2_Impact_Nice
+- SFX_Health_Potion_High_Drink
+- SFX_Health_Potion_High_Drink_Local
+- SFX_Health_Potion_Low_Drink
+- SFX_Health_Potion_Low_Drink_Local
+- SFX_Hedera_Scream
+- SFX_Hoe_T1_Swing_Down_Local
+- SFX_Hoe_T1_Till
+- SFX_Horse_Alerted
+- SFX_Horse_Death
+- SFX_Horse_Hurt
+- SFX_Horse_Idle
+- SFX_Horse_Sleep
+- SFX_Horse_Wake
+- SFX_Hyena_Alerted
+- SFX_Hyena_Death
+- SFX_Hyena_Hurt
+- SFX_Hyena_Idle
+- SFX_Ice_Ball_Death
+- SFX_Ice_Bolt_Death
+- SFX_Ice_Break
+- SFX_Ice_Build
+- SFX_Ice_Hit
+- SFX_Ice_Item_Impact
+- SFX_Ice_Item_Swing
+- SFX_Ice_Land
+- SFX_Ice_Walk
+- SFX_Incorrect_Tool
+- SFX_Item_Break
+- SFX_Item_Repair
+- SFX_Klops_Alerted
+- SFX_Klops_Death
+- SFX_Klops_Hurt
+- SFX_Klops_Idle
+- SFX_Klops_Run
+- SFX_Kweebec_Plushie_Impact
+- SFX_Lamb_Alerted
+- SFX_Lamb_Death
+- SFX_Lamb_Hurt
+- SFX_Larva_Alerted
+- SFX_Larva_Death
+- SFX_Larva_Despawn
+- SFX_Larva_Hurt
+- SFX_Larva_Spawn
+- SFX_LeavesGround_Break
+- SFX_LeavesGround_Hit
+- SFX_LeavesGround_Land
+- SFX_LeavesGround_Walk
+- SFX_Leaves_Break
+- SFX_Leaves_Hit
+- SFX_Leaves_Walk
+- SFX_Leopard_Snow_Alerted
+- SFX_Leopard_Snow_Death
+- SFX_Leopard_Snow_Hurt
+- SFX_Leopard_Snow_Run
+- SFX_Light_Melee_T1_Block
+- SFX_Light_Melee_T1_Guard_Hit
+- SFX_Light_Melee_T1_Impact
+- SFX_Light_Melee_T1_Lunge
+- SFX_Light_Melee_T1_Lunge_Charge
+- SFX_Light_Melee_T1_Shove
+- SFX_Light_Melee_T1_Swing
+- SFX_Light_Melee_T2_Block
+- SFX_Light_Melee_T2_Guard_Break
+- SFX_Light_Melee_T2_Guard_Hit
+- SFX_Light_Melee_T2_Lunge
+- SFX_Light_Melee_T2_Lunge_Charge
+- SFX_Light_Melee_T2_Swing
+- SFX_Longsword_Special_Impact
+- SFX_Longsword_Special_Swing
+- SFX_Longsword_Steel_Charged_Swing
+- SFX_Longsword_Steel_Impact
+- SFX_Longsword_Steel_Swing
+- SFX_Lumbermill_Bench_Close
+- SFX_Lumbermill_Bench_Open
+- SFX_Lumbermill_Bench_Processing
+- SFX_Mace_T1_Block_Impact
+- SFX_Mace_T1_Impact
+- SFX_Mace_T1_Raise
+- SFX_Mace_T1_Raise_Local
+- SFX_Mace_T1_Shove
+- SFX_Mace_T1_Shove_Local
+- SFX_Mace_T1_Swing
+- SFX_Mace_T1_Swing_Charged
+- SFX_Mace_T1_Swing_Charged_LR_Local
+- SFX_Mace_T1_Swing_Charged_RL_Local
+- SFX_Mace_T1_Swing_Charged_Up_Local
+- SFX_Mace_T1_Swing_LR_Local
+- SFX_Mace_T1_Swing_RL_Local
+- SFX_Mace_T1_Swing_Up_Local
+- SFX_Mace_T2_Impact
+- SFX_Mace_T2_Raise
+- SFX_Mace_T2_Raise_Local
+- SFX_Mace_T2_Signature_Impact
+- SFX_Mace_T2_Signature_Impact_Local
+- SFX_Mace_T2_Signature_Launch
+- SFX_Mace_T2_Signature_Launch_Local
+- SFX_Mace_T2_Swing
+- SFX_Mace_T2_Swing_Charged
+- SFX_Mace_T2_Swing_Charged_LR_Local
+- SFX_Mace_T2_Swing_Charged_RL_Local
+- SFX_Mace_T2_Swing_Charged_Up_Local
+- SFX_Mace_T2_Swing_LR_Local
+- SFX_Mace_T2_Swing_RL_Local
+- SFX_Mace_T2_Swing_Up_Local
+- SFX_Meerkat_Alerted
+- SFX_Meerkat_Death
+- SFX_Meerkat_Hurt
+- SFX_Meerkat_Idle
+- SFX_Memories_Unlock_Local
+- SFX_Metal_Break
+- SFX_Metal_Build
+- SFX_Metal_Hit
+- SFX_Metal_Land
+- SFX_Metal_Walk
+- SFX_Moose_Bull_Alerted
+- SFX_Mouse_Alerted
+- SFX_Mouse_Death
+- SFX_Mouse_Flee
+- SFX_Mouse_Hurt
+- SFX_Mouse_Run
+- SFX_Mouse_Sleep
+- SFX_Mud_Break
+- SFX_Mud_Build
+- SFX_Mud_Hit
+- SFX_Mud_Land
+- SFX_Mud_Walk
+- SFX_Mug_Fill
+- SFX_Mug_Fill_Local
+- SFX_Mushroom_Break
+- SFX_Mushroom_Harvest
+- SFX_Music_Ducking_2db
+- SFX_NPC_Unarmed_Impact
+- SFX_NPC_Unarmed_Swing
+- SFX_Ore_Break
+- SFX_Ore_Hit
+- SFX_Outlander_Hunter_Arrow_Hit
+- SFX_Outlander_Hunter_Arrow_Miss
+- SFX_Outlander_Hurt
+- SFX_Owl_Alerted
+- SFX_Owl_Death
+- SFX_Owl_Hurt
+- SFX_Pickaxe_T1_Swing_Down_Local
+- SFX_Pickaxe_T2_Impact_Nice
+- SFX_Pig_Alerted
+- SFX_Pig_Death
+- SFX_Pig_Hurt
+- SFX_Pig_Run
+- SFX_Pig_Walk
+- SFX_Pigeon_Death
+- SFX_Pigeon_Hurt
+- SFX_Piglet_Alerted
+- SFX_Piglet_Death
+- SFX_Piglet_Hurt
+- SFX_Piglet_Run
+- SFX_Pistol_Fire
+- SFX_Plant_Break
+- SFX_Plant_Hit
+- SFX_Plant_MoveIn
+- SFX_Player_Climb_Down
+- SFX_Player_Climb_Side
+- SFX_Player_Climb_Up
+- SFX_Player_Craft_Item_Inventory
+- SFX_Player_Death
+- SFX_Player_Death_Drown
+- SFX_Player_Death_Fall
+- SFX_Player_Drop_Item
+- SFX_Player_Fall
+- SFX_Player_Glide_Motion
+- SFX_Player_Glide_Stationary
+- SFX_Player_Grab_Item
+- SFX_Player_Hurt
+- SFX_Player_Hurt_Burn
+- SFX_Player_Hurt_Drowning
+- SFX_Player_Hurt_Fall
+- SFX_Player_Jump
+- SFX_Player_Mantle
+- SFX_Player_Pickup_Item
+- SFX_Player_Roll
+- SFX_Player_Slide
+- SFX_Player_Swim
+- SFX_Player_Swim_Fast
+- SFX_Player_Swim_Jump
+- SFX_Player_Unarmed_Swing_Left
+- SFX_Player_Unarmed_Swing_Right
+- SFX_Plushie_Break
+- SFX_Plushie_Build
+- SFX_Poop_Bounce
+- SFX_Poop_Break
+- SFX_Poop_Hit
+- SFX_Poop_Walk
+- SFX_Portal_Neutral
+- SFX_Portal_Neutral_Open
+- SFX_Portal_Neutral_Teleport_Local
+- SFX_Portal_Void
+- SFX_Potion_Drink_Success
+- SFX_Processing_Placeholder
+- SFX_Projectile_Poop_Hit
+- SFX_Rabbit_Alerted
+- SFX_Rabbit_Death
+- SFX_Rabbit_Hurt
+- SFX_Rabbit_Run
+- SFX_Rabbit_Sleep
+- SFX_Ram_Alerted
+- SFX_Ram_Death
+- SFX_Ram_Hurt
+- SFX_Ram_Run
+- SFX_Ram_Sleep
+- SFX_Raptor_Cave_Alerted
+- SFX_Raptor_Cave_Idle
+- SFX_Rat_Death
+- SFX_Rat_Hurt
+- SFX_Raven_Alerted
+- SFX_Raven_Death
+- SFX_Raven_Flee
+- SFX_Raven_Hurt
+- SFX_Reeds_MoveIn
+- SFX_Rifle_Fire
+- SFX_Rifle_Fire_Local
+- SFX_Rope_Break
+- SFX_Rope_Build
+- SFX_Rope_Land
+- SFX_Rope_Walk
+- SFX_Rotate_Pitch_Default
+- SFX_Rotate_Roll_Default
+- SFX_Rotate_Yaw_Default
+- SFX_Rubble_Bounce
+- SFX_Rubble_Hit
+- SFX_Sand_Break
+- SFX_Sand_Build
+- SFX_Sand_Hit
+- SFX_Sand_Land
+- SFX_Sand_Walk
+- SFX_Scarak_Fighter_Alerted
+- SFX_Scarak_Fighter_Death
+- SFX_Scarak_Fighter_Hurt
+- SFX_Scarak_Seeker_Alerted
+- SFX_Scarak_Seeker_Death
+- SFX_Scarak_Seeker_Hurt
+- SFX_Scarak_Seeker_Spitball_Death
+- SFX_Scarak_Spitball_Fire
+- SFX_Scorpion_Alerted
+- SFX_Scorpion_Death
+- SFX_Scorpion_Run
+- SFX_Scorpion_Threaten
+- SFX_Seeds_Place
+- SFX_Shark_Death
+- SFX_Shark_Dive
+- SFX_Shark_Hurt
+- SFX_Shark_Swim
+- SFX_Shears_Activate
+- SFX_Sheep_Alerted
+- SFX_Sheep_Death
+- SFX_Sheep_Hurt
+- SFX_Sheep_Run
+- SFX_Sheep_Sheared
+- SFX_Sheep_Walk
+- SFX_Shield_T1_Break
+- SFX_Shield_T1_Impact
+- SFX_Shield_T1_Raise
+- SFX_Shield_T1_Raise_Local
+- SFX_Shield_T1_Swing
+- SFX_Shield_T1_Swing_Local
+- SFX_Shield_T2_Impact
+- SFX_Shield_T2_Raise
+- SFX_Shield_T2_Raise_Local
+- SFX_Shield_T2_Swing
+- SFX_Shield_T2_Swing_Local
+- SFX_Shovel_T1_Swing_RL_Local
+- SFX_Shovel_T2_Impact_Nice
+- SFX_Skeleton_Alerted
+- SFX_Skeleton_Death_1
+- SFX_Skeleton_Death_2
+- SFX_Skeleton_Death_3
+- SFX_Skeleton_Death_4
+- SFX_Skeleton_Despawn_1
+- SFX_Skeleton_Despawn_2
+- SFX_Skeleton_Hurt
+- SFX_Skeleton_Mage_Spellbook_Charge
+- SFX_Skeleton_Mage_Spellbook_Impact
+- SFX_Skeleton_Praetorian_Alerted
+- SFX_Skeleton_Praetorian_Death_1
+- SFX_Skeleton_Praetorian_Death_2
+- SFX_Skeleton_Praetorian_Death_3
+- SFX_Skeleton_Praetorian_Death_4
+- SFX_Skeleton_Praetorian_Despawn_1
+- SFX_Skeleton_Praetorian_Despawn_2
+- SFX_Skeleton_Praetorian_Hurt
+- SFX_Skeleton_Praetorian_Run
+- SFX_Skeleton_Praetorian_Search_2
+- SFX_Skeleton_Praetorian_Spawn_1
+- SFX_Skeleton_Praetorian_Walk
+- SFX_Skeleton_Run
+- SFX_Skeleton_Search_2
+- SFX_Skeleton_Spawn_1
+- SFX_Skeleton_Spawn_2
+- SFX_Skeleton_Walk
+- SFX_Snake_Alerted
+- SFX_Snake_Death
+- SFX_Snake_Hurt
+- SFX_Snake_Idle
+- SFX_Snow_Break
+- SFX_Snow_Build
+- SFX_Snow_Hit
+- SFX_Snow_Land
+- SFX_Snow_Walk
+- SFX_Soft_Break
+- SFX_Soft_Build
+- SFX_Soft_Hit
+- SFX_Soft_Land
+- SFX_Soft_Walk
+- SFX_Spark_Living_Alerted
+- SFX_Spark_Living_Death
+- SFX_Sparrow_Alerted
+- SFX_Sparrow_Death
+- SFX_Sparrow_Hurt
+- SFX_Sparrow_Idle
+- SFX_Spawn_Void_Alerted
+- SFX_Spawn_Void_Attack
+- SFX_Spawn_Void_Death
+- SFX_Spawn_Void_Hurt
+- SFX_Spawn_Void_Run
+- SFX_Spear_Impact
+- SFX_Spear_Lunge
+- SFX_Spear_Lunge_Local
+- SFX_Spear_Miss
+- SFX_Spear_Projectile_Impact
+- SFX_Spear_Throw
+- SFX_Spear_Throw_Charge
+- SFX_Spear_Throw_Charge_Local
+- SFX_Spear_Throw_Local
+- SFX_Spider_Alerted
+- SFX_Spider_Death
+- SFX_Spider_Run
+- SFX_Spirit_Root_Alerted
+- SFX_Spirit_Root_Death_01
+- SFX_Spirit_Root_Death_02
+- SFX_Spirit_Root_Hurt
+- SFX_Spirit_Root_Spawn
+- SFX_Squirrel_Alerted
+- SFX_Squirrel_Death
+- SFX_Squirrel_Hurt
+- SFX_Squirrel_Run
+- SFX_Staff_Charged_Loop
+- SFX_Staff_Fire_Shoot
+- SFX_Staff_Flame_Consume_Charge_1
+- SFX_Staff_Flame_Consume_Charge_1_Local
+- SFX_Staff_Flame_Consume_Charge_2
+- SFX_Staff_Flame_Consume_Charge_2_Local
+- SFX_Staff_Flame_Consume_Charge_3
+- SFX_Staff_Flame_Consume_Charge_3_Local
+- SFX_Staff_Flame_Consume_Charge_4
+- SFX_Staff_Flame_Consume_Charge_4_Local
+- SFX_Staff_Flame_Fireball_Impact
+- SFX_Staff_Flame_Fireball_Launch
+- SFX_Staff_Flame_Fireball_Launch_Local
+- SFX_Staff_Flame_Flamethrower
+- SFX_Staff_Flame_Flamethrower_End
+- SFX_Staff_Flame_Flamethrower_End_Local
+- SFX_Staff_Flame_Flamethrower_Impact
+- SFX_Staff_Flame_Flamethrower_Local
+- SFX_Staff_Flame_Trap_Deploy
+- SFX_Staff_Flame_Trap_Despawn
+- SFX_Staff_Flame_Trap_Loop
+- SFX_Staff_Ice_Shoot
+- SFX_Stamina_Potion_Success
+- SFX_Sticks_Break
+- SFX_Stone_Break
+- SFX_Stone_Build
+- SFX_Stone_Coffin_Open_Close
+- SFX_Stone_Harvest
+- SFX_Stone_Hit
+- SFX_Stone_Land
+- SFX_Stone_Walk
+- SFX_Sword_T1_Block_Local
+- SFX_Sword_T1_Lunge_Charge_Local
+- SFX_Sword_T1_Lunge_Local
+- SFX_Sword_T1_Shove_Local
+- SFX_Sword_T1_Swing_Down_Local
+- SFX_Sword_T1_Swing_LR_Local
+- SFX_Sword_T1_Swing_RL_Local
+- SFX_Sword_T2_Block_Local
+- SFX_Sword_T2_Impact
+- SFX_Sword_T2_Lunge_Charge_Local
+- SFX_Sword_T2_Lunge_Local
+- SFX_Sword_T2_Signature_Part_1
+- SFX_Sword_T2_Signature_Part_1_Local
+- SFX_Sword_T2_Signature_Part_2
+- SFX_Sword_T2_Signature_Part_2_Local
+- SFX_Sword_T2_Swing_Down_Local
+- SFX_Sword_T2_Swing_LR_Local
+- SFX_Sword_T2_Swing_RL_Local
+- SFX_T1_Impact_Blunt
+- SFX_Tall_Grass_MoveIn
+- SFX_Test_Blip_A
+- SFX_Test_Blip_B
+- SFX_Test_Blip_C
+- SFX_Tetrabird_Alerted
+- SFX_Tetrabird_Death
+- SFX_Tetrabird_Flee
+- SFX_Tetrabird_Hurt
+- SFX_Tetrabird_Run
+- SFX_Tiger_Sabertooth_Alerted
+- SFX_Tiger_Sabertooth_Death
+- SFX_Tiger_Sabertooth_Hurt
+- SFX_Tiger_Sabertooth_Run
+- SFX_Toad_Rhino_Alerted
+- SFX_Toad_Rhino_Death
+- SFX_Toad_Rhino_Hurt
+- SFX_Toad_Rhino_Magma_Alerted
+- SFX_Toad_Rhino_Magma_Death
+- SFX_Toad_Rhino_Magma_Hurt
+- SFX_Toad_Rhino_Magma_Run
+- SFX_Toad_Rhino_Magma_Tongue_Impact
+- SFX_Toad_Rhino_Magma_Tongue_Whoosh
+- SFX_Toad_Rhino_Run
+- SFX_Toad_Rhino_Tongue_Impact
+- SFX_Toad_Rhino_Tongue_Whoosh
+- SFX_Tombstone_Break
+- SFX_Tool_T1_Swing
+- SFX_Tool_Watering_Can_Water
+- SFX_Torch_Break
+- SFX_Torch_Build
+- SFX_Torch_Default_Loop
+- SFX_Torch_Impact
+- SFX_Torch_Off
+- SFX_Torch_On_Loop
+- SFX_Torch_Swing
+- SFX_Torch_Swing_Left_Local
+- SFX_Torch_Swing_Right_Local
+- SFX_Tornado
+- SFX_Trashpile_Land
+- SFX_Trashpile_Walk
+- SFX_Trork_Alerted
+- SFX_Trork_Chieftain_Alerted
+- SFX_Trork_Chieftain_Death
+- SFX_Trork_Chieftain_Hurt
+- SFX_Trork_Chieftain_Run
+- SFX_Trork_Chieftain_Search
+- SFX_Trork_Death
+- SFX_Trork_Exertion
+- SFX_Trork_Hurt_01
+- SFX_Trork_Hurt_02
+- SFX_Trork_Run
+- SFX_Trork_Search
+- SFX_Trork_Sleep
+- SFX_Trork_Throwing_Axe
+- SFX_Unarmed_Impact
+- SFX_Unarmed_Swing
+- SFX_Unbreakable_Block
+- SFX_Vulture_Alerted
+- SFX_Vulture_Death
+- SFX_Vulture_Flee
+- SFX_Vulture_Hurt
+- SFX_Wand_Fire_Shoot
+- SFX_Wand_Ice_Shoot
+- SFX_Warthog_Alerted
+- SFX_Warthog_Death
+- SFX_Warthog_Hurt
+- SFX_Warthog_Piglet_Alerted
+- SFX_Warthog_Piglet_Death
+- SFX_Warthog_Piglet_Hurt
+- SFX_Warthog_Piglet_Run
+- SFX_Warthog_Run
+- SFX_Warthog_Sleep
+- SFX_Warthog_Walk
+- SFX_Water_MoveIn
+- SFX_Water_MoveOut
+- SFX_Weapon_Bench_Close
+- SFX_Weapon_Bench_Craft
+- SFX_Weapon_Bench_Open
+- SFX_Weapon_Charge_Swing
+- SFX_Web_MoveIn
+- SFX_Window_Break
+- SFX_Window_Stone_Break
+- SFX_Wisp_Lamp_Loop
+- SFX_Wolf_Alerted
+- SFX_Wolf_Death
+- SFX_Wolf_Hurt
+- SFX_Wolf_Run
+- SFX_Wolf_Sleep
+- SFX_Wood_Break
+- SFX_Wood_Build
+- SFX_Wood_Hit
+- SFX_Wood_Land
+- SFX_Wood_Walk
+- SFX_Woodpecker_Death
+- SFX_Woodpecker_Hurt
+- SFX_Workbench_Close
+- SFX_Workbench_Craft
+- SFX_Workbench_Open
+- SFX_Workbench_Upgrade_Complete_Default
+- SFX_Workbench_Upgrade_Start_Default
+- SFX_Yeti_Alerted
+- SFX_Z1_Emit_Forest_Autumn_Day_Birds
+- SFX_Z1_Emit_Forest_Autumn_Day_Insects
+- SFX_Z1_Emit_Forest_Autumn_Day_Wind
+- SFX_Z1_Emit_Forest_Azure_Day_Insects
+- SFX_Z1_Emit_Forest_Azure_Day_Wind
+- SFX_Z1_Emit_Forest_Gen_Day_Birds
+- SFX_Z1_Emit_Forest_Gen_Day_Insects
+- SFX_Z1_Emit_Forest_Gen_Day_Winds
+- SFX_Z1_Emit_Forest_Moss_Day_Birds
+- SFX_Z1_Emit_Forest_Moss_Day_Insects
+- SFX_Z1_Emit_Forest_Moss_Day_Wind
+- SFX_Z1_Emit_Forest_Night_Birds
+- SFX_Z1_Emit_Forest_Night_Insects
+- SFX_Z1_Emit_Forest_Night_Wind
+- SFX_Z1_Emit_Kweebec_Village_Wind
+- SFX_Z1_Emit_Mountain_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Insects
+- SFX_Z1_Emit_Plains_Gen_Day_Wind
+- SFX_Z1_Emit_Plains_Gen_Night_Birds
+- SFX_Z1_Emit_Plains_Gen_Night_Insects
+- SFX_Z1_Emit_Plains_Gen_Night_Wind
+- SFX_Z1_Emit_Shore_Day_Birds
+- SFX_Z1_Emit_Shore_Waves
+- SFX_Z1_Emit_Shore_Wind
+- SFX_Z1_Emit_Swamp_Day_Birds
+- SFX_Z1_Emit_Swamp_Day_Frogs
+- SFX_Z1_Emit_Swamp_Day_Insects
+- SFX_Z1_Emit_Swamp_Day_Wind
+- SFX_Z1_Emit_Swamp_Night_Frogs
+- SFX_Z1_Emit_Trork_Camp
+- SFX_Z1_Shore_Day_Birds
+- SFX_Z3_Emit_Cave_Ice_Crackle
+- SFX_Z3_Emit_Cave_Ice_Rumble
+- SFX_Z3_Emit_Cave_Ice_Stress
+- SFX_Z3_Emit_Cave_Snow_Crackle
+- SFX_Z3_Emit_Cave_Snow_Melt
+- SFX_Z3_Emit_Hedera_FX
+- SFX_Z3_Emit_Hedera_PlantRustle
+- SFX_Z3_Emit_Tree_Creak
+- SFX_Z3_Emit_Wind_Leaves
+- SFX_Z3_Emit_Wind_Leaves_Stereo
+- SFX_Z3_Forest_Day_Birds
+- SFX_Z3_Forest_Day_General
+- SFX_Z3_Forest_Night_Birds
+- SFX_Zombie_Alerted
+- SFX_Zombie_Attack_Bite
+- SFX_Zombie_Attack_Swing
+- SFX_Zombie_Death
+- SFX_Zombie_Despawn
+- SFX_Zombie_Hurt
+- SFX_Zombie_Pursuit
+- SFX_Zombie_ScratchBack
+- SFX_Zombie_Spawn
diff --git a/content/docs/ro-RO/guides/ecs/entity-component-system.mdx b/content/docs/ro-RO/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/ro-RO/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/ro-RO/guides/ecs/example-ecs-plugin.mdx b/content/docs/ro-RO/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/ro-RO/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/ro-RO/guides/ecs/hytale-ecs-theory.mdx b/content/docs/ro-RO/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/ro-RO/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/ro-RO/guides/ecs/systems.mdx b/content/docs/ro-RO/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/ro-RO/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/ro-RO/guides/java-basics/00-introduction.mdx b/content/docs/ro-RO/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/ro-RO/guides/java-basics/00-introduction.mdx
+++ b/content/docs/ro-RO/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/ro-RO/guides/java-basics/06-methods-functions.mdx b/content/docs/ro-RO/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/ro-RO/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/ro-RO/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/ro-RO/guides/plugin/block-components.mdx b/content/docs/ro-RO/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/ro-RO/guides/plugin/browsing-serverjar.mdx b/content/docs/ro-RO/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/ro-RO/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/ro-RO/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/ro-RO/guides/plugin/build-and-test.mdx b/content/docs/ro-RO/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/ro-RO/guides/plugin/chat-formatting.mdx b/content/docs/ro-RO/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/ro-RO/guides/plugin/chat-formatting.mdx
+++ b/content/docs/ro-RO/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/ro-RO/guides/plugin/client-inputs-reference.mdx b/content/docs/ro-RO/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/ro-RO/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/ro-RO/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/ro-RO/guides/plugin/creating-block.mdx b/content/docs/ro-RO/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/ro-RO/guides/plugin/creating-block.mdx
+++ b/content/docs/ro-RO/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/ro-RO/guides/plugin/creating-commands.mdx b/content/docs/ro-RO/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/ro-RO/guides/plugin/creating-commands.mdx
+++ b/content/docs/ro-RO/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/ro-RO/guides/plugin/creating-configuration-file.mdx b/content/docs/ro-RO/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/ro-RO/guides/plugin/creating-events.mdx b/content/docs/ro-RO/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/ro-RO/guides/plugin/creating-events.mdx
+++ b/content/docs/ro-RO/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/ro-RO/guides/plugin/customizing-camera-controls.mdx b/content/docs/ro-RO/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/ro-RO/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/ro-RO/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/ro-RO/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/ro-RO/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/ro-RO/guides/plugin/instances.mdx b/content/docs/ro-RO/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/ro-RO/guides/plugin/inventory-management.mdx b/content/docs/ro-RO/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/ro-RO/guides/plugin/inventory-management.mdx
+++ b/content/docs/ro-RO/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/ro-RO/guides/plugin/item-interaction.mdx b/content/docs/ro-RO/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/ro-RO/guides/plugin/listening-to-packets.mdx b/content/docs/ro-RO/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/ro-RO/guides/plugin/logging.mdx b/content/docs/ro-RO/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/ro-RO/guides/plugin/player-death-event.mdx b/content/docs/ro-RO/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/ro-RO/guides/plugin/player-input-guide.mdx b/content/docs/ro-RO/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/ro-RO/guides/plugin/player-input-guide.mdx
+++ b/content/docs/ro-RO/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/ro-RO/guides/plugin/player-stats.mdx b/content/docs/ro-RO/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/ro-RO/guides/plugin/setting-up-env.mdx b/content/docs/ro-RO/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/ro-RO/guides/plugin/setting-up-env.mdx
+++ b/content/docs/ro-RO/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/ro-RO/guides/plugin/spawning-entities.mdx b/content/docs/ro-RO/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/ro-RO/guides/plugin/spawning-entities.mdx
+++ b/content/docs/ro-RO/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/ro-RO/guides/plugin/spawning-npcs.mdx b/content/docs/ro-RO/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/ro-RO/guides/plugin/store-persistant-data.mdx b/content/docs/ro-RO/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/ro-RO/guides/plugin/teleporting-players.mdx b/content/docs/ro-RO/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/ro-RO/guides/plugin/teleporting-players.mdx
+++ b/content/docs/ro-RO/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/ro-RO/guides/plugin/text-hologram.mdx b/content/docs/ro-RO/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/ro-RO/guides/plugin/ui.mdx b/content/docs/ro-RO/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/ro-RO/guides/plugin/world-gen.mdx b/content/docs/ro-RO/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/ro-RO/guides/plugin/world-gen.mdx
+++ b/content/docs/ro-RO/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/ro-RO/guides/prefabs.mdx b/content/docs/ro-RO/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/ro-RO/guides/prefabs.mdx
+++ b/content/docs/ro-RO/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/ro-RO/official-documentation/npc-doc.mdx b/content/docs/ro-RO/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/ro-RO/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/ro-RO/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/ro-RO/publishing/builtbybit.mdx b/content/docs/ro-RO/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/ro-RO/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/ro-RO/publishing/index.mdx b/content/docs/ro-RO/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/ro-RO/publishing/index.mdx
+++ b/content/docs/ro-RO/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/ru-RU/established-information/developer-qa-insights.mdx b/content/docs/ru-RU/established-information/developer-qa-insights.mdx
index 47915c97..9d01cfbf 100644
--- a/content/docs/ru-RU/established-information/developer-qa-insights.mdx
+++ b/content/docs/ru-RU/established-information/developer-qa-insights.mdx
@@ -1,42 +1,42 @@
 ---
-title: Developer Q&A Technical Insights
-description: Comprehensive summary of technical insights from Hytale developers covering architecture, modding, gameplay systems, and development philosophy.
+title: Вопросы и ответы разработчиков & Технические подробности
+description: Подробное резюме технических идей разработчиков Hytale, охватывающее архитектуру, моддинг, игровые системы и философию разработки.
 ---
 
-# Developer Q&A Technical Insights
+# Вопросы и ответы разработчиков & Технические подробности
 
-This extensive Q&A session with Hytale developers reveals critical technical details about the game's architecture, modding philosophy, gameplay systems, and development approach.
+В ходе этой обширной сессии вопросов и ответов с разработчиками Hytale раскрываются важные технические детали об архитектуре игры, философии моддинга, игровых системах и подходе к разработке.
 
-## Technical Architecture
+## Техническая архитектура
 
-### Network & Infrastructure
+### Сеть и инфраструктура
 
-* **Protocol**: Uses QUIC (reliable UDP with unreliable channels) instead of TCP
-* **Server Compatibility**: Runs on any platform supporting Java 25
-* **Connection Method**: Direct IP initially, server discovery planned post-launch
-* **Data Layer**: Current custom serialization format will be replaced post-launch
-* **Performance**: Multi-core support - each world has main thread + parallel execution
-* **Rendering**: OpenGL 3.3 for Mac compatibility, potential future Vulkan/Metal migration
-* **Tick Model**: Base server tick rate is 30 TPS by default; can be changed using server plugins.
+* **Протокол**: использует QUIC (надежный UDP с ненадежными каналами) вместо TCP.
+* **Совместимость с серверами**: Работает на любой платформе, поддерживающей Java 25.
+* **Метод подключения**: сначала прямой IP, после запуска планируется обнаружение сервера.
+* **Уровень данных**: текущий пользовательский формат сериализации будет заменен после запуска.
+* **Производительность**: поддержка многоядерных процессоров — каждый мир имеет основной поток + параллельное выполнение
+* **Рендеринг**: OpenGL 3.3 для совместимости с Mac, потенциальный переход на Vulkan/Metal в будущем
+* **Модель тиков**:  тикрейт 30 TPS по умолчанию; можно изменить с помощью серверных плагинов.
 
-### Security & Distribution
+### Безопасность и распространение
 
-* **No Client-Side Code Execution**: Prevents remote code execution exploits
-* **Downloads Limited To**: Configuration files and assets only
-* **Mod Distribution**: Community platforms (CurseForge, Modrinth), no immediate in-game marketplace
-* **Server Hosting**: Available day 1, no business agreements required (just EULA/TOS)
+* **Отсутствие выполнения кода на стороне клиента**: предотвращает уязвимости, связанные с удаленным выполнением кода.
+* **Скачивание ограничено**: только конфигурационные файлы и ресурсы
+* **Распространение модов**: платформы сообщества (CurseForge, Modrinth), нет непосредственного внутриигрового маркетплейса
+* **Хостинг сервера**: доступен с первого дня, не требуется заключение деловых соглашений (только EULA/TOS)
 
-## Modding Capabilities
+## Возможности моддинга
 
-### Server-Side Power
+### Мощность со стороны сервера
 
-* **Full Java Access**: Database connections, web requests, any Java functionality
-* **Custom Libraries**: Can create Lua scripting, ML frameworks, or any Java library
-* **Server Modification**: Shared source code allows heavy server modifications
-* **Hot Reload**: Supported for most asset types
-* **Documentation**: Public GitBook planned, though initially sparse
+* **Полный доступ к Java**: соединения с базами данных, веб-запросы, любая функциональность Java
+* **Пользовательские библиотеки**: можно создавать скрипты Lua, ML-фреймворки или любые Java-библиотеки
+* **Моддинг сервера**: общий исходный код позволяет вносить значительные изменения в сервер
+* **Горячая перезагрузка**: поддерживается для большинства типов ресурсов
+* **Документация**: Планируется создание общедоступного GitBook, хотя изначально он будет содержать не так много информации
 
-### Content Creation (No Code Required)
+### Создание контента (без кодинга)
 
 * **World Generation**: Custom biomes and maps without Java
 * **NPCs & Items**: JSON-based configuration
diff --git a/content/docs/ru-RU/established-information/server/content-categories/art-assets.mdx b/content/docs/ru-RU/established-information/server/content-categories/art-assets.mdx
index b1b1fede..e4fa05d7 100644
--- a/content/docs/ru-RU/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/ru-RU/established-information/server/content-categories/art-assets.mdx
@@ -90,7 +90,7 @@ Hytale использует различную плотность пикселе
 
 Hytale использует другой подход к материалам по сравнению с другими движками:
 
-* \*\*\* Пре-оптимизированные\*\*: Материалы очень оптимизированы, и художники не могут создавать свои собственные материалы
+* **Пре-оптимизированные**: Материалы очень оптимизированы, и художники не могут создавать свои собственные материал
 * **Приоритет производительности**: это ограничение обеспечивает производительность всего контента
 * **Курируемая система**: Поддерживает визуальную последовательность при повышении эффективности
 
diff --git a/content/docs/ru-RU/established-information/server/interface/ui-customization.mdx b/content/docs/ru-RU/established-information/server/interface/ui-customization.mdx
index d2acbd6b..26ca4a75 100644
--- a/content/docs/ru-RU/established-information/server/interface/ui-customization.mdx
+++ b/content/docs/ru-RU/established-information/server/interface/ui-customization.mdx
@@ -1,80 +1,78 @@
 ---
-title: UI Customization
-description: Information about UI customization in Hytale.
+title: Кастомизация пользовательского интерфейса
+description: Информация о кастомизации интерфейса в Hytale.
 ---
 
-UI can be customized via **server-side** modding. Many of the UI pages shown to players are available to be modified by server owners through mods.
+Пользовательский интерфейс (UI) можно кастомизировать с помощью **серверного** моддинга. В Hytale много возможностей для создателей модов и большая часть доступного для игрока UI можно переделать под себя.
 
-## UI Customization in Hytale
+## Кастомизация UI в Hytale
 
-Hytale provides extensive UI customization capabilities through server-side modding, allowing server owners to modify many of the UI pages that players interact with.
+Hytale предоставляет обширные возможности для настройки UI посредством моддинга на стороне сервера, что позволяет владельцам серверов изменять многие части UI, с которыми взаимодействуют игроки.
 
-### Control Flow
+### Управление потоками
 
-The UI system in Hytale follows a specific control flow pattern:
+Система UI в Hytale соответствует определенной схеме управления потоком:
 
-1. Server sends UI data to the client
-2. Client renders the UI
-3. User interacts with the UI (e.g., pressing a button)
-4. Client sends the interaction event to the server
-5. Server executes the callback logic for the event
+1. Сервер отправляет UI данные клиенту
+2. Клиент рендерит пользовательский интерфейс
+3. Пользователь взаимодействует с интерфейсом (например, нажатие кнопки)
+4. Клиент отправляет событие взаимодействия на сервер
+5. Сервер выполняет логику обратного вызова для события
 
-This architecture means:
+Такая архитектура означает:
 
-* The client is responsible for rendering UI and sending user interactions to the server
-* The server handles all the actual logic behind user interactions
+* Клиент отвечает за рендеринг пользовательского интерфейса и отправку взаимодействия пользователя на сервер
+* Сервер обрабатывает всю фактическую логику взаимодействия с пользователем
 
-<Callout type="warning" title="Possible Performance Implications">
+<Callout type="warning" title="Возможные последствия для производительности">
   <span>
-    Because the server processes all UI logic, there is an inherent latency
-    impact on UI responsiveness. Button clicks and other interactions must
-    travel to the server before taking effect, meaning network ping directly
-    affects UI responsiveness.
+    Поскольку сервер обрабатывает всю логику интерфейса, существует задержка, которая влияет на скорость отклика UI. Нажатия кнопок и другие взаимодействия должны
+    дойти до сервера, прежде чем вступить в силу, а это означает, что пинг напрямую
+    влияет на отклик UI.
   </span>
 
   <span>
-    Additionally, since client-side modding is not supported, no modded values
-    persist on the client.
+    Кроме того, поскольку моддинг на стороне клиента не поддерживается, модифицированные элементы не сохраняются на клиенте.
   </span>
 </Callout>
 
-### UI Layout Assets
+### Ассеты слоёв интерфейса
 
-Hytale's UI customization system works through the following structure:
+Система кастомизации интерфейса Hytale работает по следующей структуре:
 
-* **UI Layout**: Sent to the client as an asset
-* **UI Behavior**: Defined in Java code
-* **Custom Layouts**: Enables creation of bespoke UI layouts rather than repurposing existing ones (unlike inventory menu modifications in Minecraft)
+* **Макет UI**: Отправляется клиенту в ассета
+* **Поведение пользовательского интерфейса**: Определено в Java коде
+* **Пользовательские макеты**: позволяет создавать индивидуальные макеты пользовательского интерфейса вместо переделки существующих (в отличие от модификаций инвентаря в Minecraft).
 
-### UI Framework Implementations
+### Реализации фрэймворков пользовательского интерфейса
 
-Hytale currently supports multiple UI implementations, with plans to consolidate on NoesisGUI:
+Hytale в настоящее время поддерживает несколько реализаций UI, при этом планируется перейти на NoesisGUI:
 
-#### Legacy Implementation
+#### Legacy реализация
 
-* Serves as an example of server modding capabilities
-* Uses a combination of in-game elements, UI Markup Assets, and Java mod code
-* Utilizes a legacy custom markup language
-* Will be deprecated in favor of NoesisGUI
+* Служит примером возможностей серверного моддинга
+* Использует комбинацию игровых элементов, ассетов разметки UI и кода мода на базе Java.
+* Использует legacy язык разметки
+* Будет признано устаревшим в пользу NoesisGUI
 
-#### NoesisGUI (Primary Framework)
+#### NoesisGUI (главный фреймворк)
 
-* Uses XAML Markup Language for UI definition
-* Supports multiple languages for internationalization
-* Runs on C# bindings on the client side (not C++)
-* Represents the future direction of Hytale's UI system
+* Использует язык разметки XAML для определения UI
+* Поддержка нескольких языков для интернационализации
+* Работает на C#-привязках на стороне клиента (не C++)
+* Представляет будущее направление развития системы пользовательского интерфейса Hytale
 
-#### Third Framework
+#### Сторонний фреймворк
 
-* Currently being phased out
-* Will be replaced by NoesisGUI as part of the consolidation effort
+* Сейчас на стадии завершения использования
+* Будет заменено NoesisGUI в рамках унификации
 
-### Performance Considerations
+### Особенности производительности
 
-Due to the server-side nature of UI processing, there are inherent performance characteristics to consider:
+Поскольку обработка UI выполняется на стороне сервера, необходимо учитывать некоторые особенности производительности:
 
-* **Latency Impact**: Button clicks and UI interactions must travel to the server before taking effect, meaning network ping directly affects UI responsiveness
-* **No Client Persistence**: Since client-side modding is not supported, no modded values persist on the client
-* **Optimized Architecture**: Hytale's system is designed to minimize latency through efficient communication protocols and optimized server performance, ensuring smooth interactions despite server-side processing requirements
+* **Влияние на задержку**: нажатия кнопок и взаимодействия с пользовательским интерфейсом должны быть отправлены на сервер, прежде чем вступят в силу, а это означает, что пинг напрямую влияет на скорость отклика UI.
+* **Нет сохранения на стороне клиента**: поскольку модификация на стороне клиента не поддерживается, измененные элементы не сохраняются на стороне клиента.
+* **Оптимизированная архитектура**: система Hytale разработана для минимизации задержек за счет эффективных протоколов связи и оптимизации производительности сервера, что гарантирует стабильную работу несмотря на обработку кода на стороне сервера
 
-The architecture prioritizes security and consistency by centralizing UI logic on the server while maintaining responsive user experiences
+Архитектура ставит во главу угла безопасность и согласованность, централизуя логику пользовательского интерфейса на сервере и сохраняя при этом отзывчивость пользовательского интерфейса.
diff --git a/content/docs/ru-RU/established-information/server/server-first-dev.mdx b/content/docs/ru-RU/established-information/server/server-first-dev.mdx
index 1ed97a61..681af8bd 100644
--- a/content/docs/ru-RU/established-information/server/server-first-dev.mdx
+++ b/content/docs/ru-RU/established-information/server/server-first-dev.mdx
@@ -1,29 +1,28 @@
 ---
-title: Server-First Development
-description: Information regarding what Server-First Development means, and more.
+title: Сервероориентированная разработка
+description: Информация о том, что означает "сервероориентированная разработка" и многое другое.
 ---
 
-Hytale is being developed with a "server-first" approach. This means that the server is considered the authoritative source of game state and logic, while the client primarily handles rendering and user input.
+Hytale разрабатывается с использованием подхода "сервероориентированная разработка". Это означает, что сервер считается основным источником состояния и логики игры, в то время как клиент в основном занимается рендерингом и обработкой ввода пользователя.
 
-## What does "Server-First" mean?
+## Что означает "сервероориентированная разработка"?
 
-In a server-first architecture, the server is responsible for managing the game world, enforcing rules, and processing player actions. The client connects to the server to receive updates about the game state and to send player inputs. This approach helps ensure consistency and fairness in multiplayer environments, as the server has control over the game logic.
+В сервероориентированной архитектуре сервер отвечает за управление игровым миром, обеспечение соблюдения правил и обработку действий игроков. Клиент подключается к серверу, чтобы получать обновления о состоянии игры и отправлять вводные данные игрока. Этот подход помогает обеспечить согласованность и справедливость в многопользовательской игре, поскольку сервер контролирует игровую логику.
 
-## Benefits of Server-First Development
+## Преимущества "сервероориентированной разработки"
 
-* **Consistency**: Since the server is the authoritative source, all players experience the same game state, reducing discrepancies and cheating.
-* **Scalability**: Server-first architectures can be more easily scaled to accommodate large numbers
-  of players, as the server can manage resources and distribute load effectively.
-* **Security**: By centralizing game logic on the server, it becomes more difficult for players to manipulate the game state unfairly.
-* **Easier Updates**: Updates and changes can be made on the server side without requiring players to download new client versions.
-* **Only One Version**: There won't be a version selector for the Hytale Client, meaning that server owners do not need to support multiple versions and can rely on everyone being on the latest client. This will help both server owners and modders.
+* **Согласованность**: Поскольку сервер является основным источником, все игроки видят одно и то же состояние игры, что снижает десинхронизацию и возможности для читерства.
+* **Масштабируемость**: архитектуры, ориентированные на сервер, можно легче масштабировать для обслуживания большого количества игроков, поскольку сервер может эффективно управлять ресурсами и распределять нагрузку.
+* **Безопасность**: благодаря централизации игровой логики на сервере игрокам становится сложнее манипулировать состоянием игры прибегая к не самым честным методам.
+* **Более простые обновления**: обновления и изменения могут вноситься на стороне сервера без необходимости загрузки игроками новых версий клиента.
+* **Только одна версия**: в клиенте Hytale не будет множества разных версий, что означает, что владельцы серверов не должны волноваться по поводу поддержки несколько версий и могут рассчитывать на то, что все пользователи будут использовать последнюю версию клиента. Это должно помочь обеим сторонам: владельцам серверов и мододелам.
 
-## Implications for Modding
+## Значение для моддинга
 
-Modders will primarily interact with the server-side components of Hytale. This means that mods will often focus on altering game logic, rules, and behaviors that are managed by the server. Client-side modifications are not allowed (as of the information given right now).
+Моддеры будут в основном взаимодействовать с серверными компонентами Hytale. Это означает, что моды часто будут сосредоточены на изменении игровой логики, правил и поведения, которые управляются сервером. Изменения на стороне клиента не допускаются (на момент выхода данного гайда).
 
-Overall, the server-first approach in Hytale aims to create a robust and fair multiplayer experience while providing modders with powerful tools to customize and enhance the game.
+В целом, подход "сервер прежде всего" в Hytale направлен на создание надежного и правильного многопользовательского опыта, предоставляя моддерам мощные инструменты для кастомизации и улучшения игры.
 
-## Conclusion
+## Заключение
 
-The server-first development model is a key aspect of Hytale's architecture, ensuring a consistent and secure multiplayer experience. Modders should focus on server-side modifications to fully leverage the capabilities of this approach and create engaging content for players.
+Сервероориентированная модель разработки является ключевым аспектом архитектуры Hytale, обеспечивающим стабильную и безопасную многопользовательскую игру. Моддеры должны сосредоточиться на модификациях на стороне сервера, чтобы в полной мере использовать возможности этого подхода и создавать увлекательный контент для игроков.
diff --git a/content/docs/ru-RU/guides/ecs/entity-component-system.mdx b/content/docs/ru-RU/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/ru-RU/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/ru-RU/guides/ecs/example-ecs-plugin.mdx b/content/docs/ru-RU/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/ru-RU/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/ru-RU/guides/ecs/hytale-ecs-theory.mdx b/content/docs/ru-RU/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/ru-RU/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/ru-RU/guides/ecs/systems.mdx b/content/docs/ru-RU/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/ru-RU/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/ru-RU/guides/java-basics/00-introduction.mdx b/content/docs/ru-RU/guides/java-basics/00-introduction.mdx
index 6cea2d78..ff213ef2 100644
--- a/content/docs/ru-RU/guides/java-basics/00-introduction.mdx
+++ b/content/docs/ru-RU/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Java - мощный, объектно-ориентированный язык п
 
 ### Java Development Kit (JDK)
 
-Скачайте и установите JDK 25 или выше с [официального вебсайта Oracle](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) или используй open-source (с исходным кодом) альтернативу, например [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Интегрированная Среда Разработки (IDE)
+### Integrated Development Environment (IDE)
 
 IDE - это программное обеспечение, которое предоставляет комплексные возможности программистам для разработки программного обеспечения. Самые популярные варианты для Java включают:
 
diff --git a/content/docs/ru-RU/guides/java-basics/01-variables.mdx b/content/docs/ru-RU/guides/java-basics/01-variables.mdx
index 263361fe..aa52e9e0 100644
--- a/content/docs/ru-RU/guides/java-basics/01-variables.mdx
+++ b/content/docs/ru-RU/guides/java-basics/01-variables.mdx
@@ -18,10 +18,10 @@ description: Введение в переменные и типы данных 
 В Java вы должны объявить переменную, прежде чем использовать её, как если бы вам понадобилась коробка перед тем, как вставить что-то в неё. Синтаксис:
 
 ```java
-int age; // A declaration
-age = 18; // An assignment
+int age; // Объявление
+age = 18; // Присвоение
 
-int age = 18; // Declaration and assignment in one line, also considered an initialization
+int age = 18; // Объявление и присвоение в одной строке
 ```
 
 ## Примитивные типы данных
diff --git a/content/docs/ru-RU/guides/java-basics/06-methods-functions.mdx b/content/docs/ru-RU/guides/java-basics/06-methods-functions.mdx
index 98a91cb8..1352d1b6 100644
--- a/content/docs/ru-RU/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/ru-RU/guides/java-basics/06-methods-functions.mdx
@@ -375,6 +375,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Содержит как минимум одно число
    * Возвращает true, если пароль достаточно надёжный, false, если нет
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Распространённые ошибки
 
 ```java
diff --git a/content/docs/ru-RU/guides/plugin/block-components.mdx b/content/docs/ru-RU/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/ru-RU/guides/plugin/browsing-serverjar.mdx b/content/docs/ru-RU/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/ru-RU/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/ru-RU/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/ru-RU/guides/plugin/build-and-test.mdx b/content/docs/ru-RU/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/ru-RU/guides/plugin/chat-formatting.mdx b/content/docs/ru-RU/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/ru-RU/guides/plugin/chat-formatting.mdx
+++ b/content/docs/ru-RU/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/ru-RU/guides/plugin/client-inputs-reference.mdx b/content/docs/ru-RU/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/ru-RU/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/ru-RU/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/ru-RU/guides/plugin/creating-block.mdx b/content/docs/ru-RU/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/ru-RU/guides/plugin/creating-block.mdx
+++ b/content/docs/ru-RU/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/ru-RU/guides/plugin/creating-commands.mdx b/content/docs/ru-RU/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/ru-RU/guides/plugin/creating-commands.mdx
+++ b/content/docs/ru-RU/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/ru-RU/guides/plugin/creating-configuration-file.mdx b/content/docs/ru-RU/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/ru-RU/guides/plugin/creating-events.mdx b/content/docs/ru-RU/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/ru-RU/guides/plugin/creating-events.mdx
+++ b/content/docs/ru-RU/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/ru-RU/guides/plugin/customizing-camera-controls.mdx b/content/docs/ru-RU/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/ru-RU/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/ru-RU/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/ru-RU/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/ru-RU/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/ru-RU/guides/plugin/instances.mdx b/content/docs/ru-RU/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/ru-RU/guides/plugin/inventory-management.mdx b/content/docs/ru-RU/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/ru-RU/guides/plugin/inventory-management.mdx
+++ b/content/docs/ru-RU/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/ru-RU/guides/plugin/item-interaction.mdx b/content/docs/ru-RU/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/ru-RU/guides/plugin/listening-to-packets.mdx b/content/docs/ru-RU/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/ru-RU/guides/plugin/logging.mdx b/content/docs/ru-RU/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/ru-RU/guides/plugin/player-death-event.mdx b/content/docs/ru-RU/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/ru-RU/guides/plugin/player-input-guide.mdx b/content/docs/ru-RU/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/ru-RU/guides/plugin/player-input-guide.mdx
+++ b/content/docs/ru-RU/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/ru-RU/guides/plugin/player-stats.mdx b/content/docs/ru-RU/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/ru-RU/guides/plugin/setting-up-env.mdx b/content/docs/ru-RU/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/ru-RU/guides/plugin/setting-up-env.mdx
+++ b/content/docs/ru-RU/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/ru-RU/guides/plugin/spawning-entities.mdx b/content/docs/ru-RU/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/ru-RU/guides/plugin/spawning-entities.mdx
+++ b/content/docs/ru-RU/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/ru-RU/guides/plugin/spawning-npcs.mdx b/content/docs/ru-RU/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/ru-RU/guides/plugin/store-persistant-data.mdx b/content/docs/ru-RU/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/ru-RU/guides/plugin/teleporting-players.mdx b/content/docs/ru-RU/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/ru-RU/guides/plugin/teleporting-players.mdx
+++ b/content/docs/ru-RU/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/ru-RU/guides/plugin/text-hologram.mdx b/content/docs/ru-RU/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/ru-RU/guides/plugin/ui.mdx b/content/docs/ru-RU/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/ru-RU/guides/plugin/world-gen.mdx b/content/docs/ru-RU/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/ru-RU/guides/plugin/world-gen.mdx
+++ b/content/docs/ru-RU/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/ru-RU/guides/prefabs.mdx b/content/docs/ru-RU/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/ru-RU/guides/prefabs.mdx
+++ b/content/docs/ru-RU/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/ru-RU/official-documentation/npc-doc.mdx b/content/docs/ru-RU/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/ru-RU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/ru-RU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/ru-RU/publishing/builtbybit.mdx b/content/docs/ru-RU/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/ru-RU/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/ru-RU/publishing/index.mdx b/content/docs/ru-RU/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/ru-RU/publishing/index.mdx
+++ b/content/docs/ru-RU/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/ru-RU/quick-start.mdx b/content/docs/ru-RU/quick-start.mdx
index 12b4e8a5..18ab3e2d 100644
--- a/content/docs/ru-RU/quick-start.mdx
+++ b/content/docs/ru-RU/quick-start.mdx
@@ -1,11 +1,11 @@
 ---
-title: Быстрый Старт
-description: Основы и концепции создания модов для Hytale.
+title: Quick Start
+description: Setting up a standard Hytale project.
 ---
 
-Добро пожаловать в документацию по моддингу Hytale! Здесь вы найдёте всё необходимое для создания своих собственных модов для Hytale.
+Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
 
-* [Основы Java](./guides/java-basics/00-introduction)  
-* [Подготовка и настройка окружения для разработки](./guides/plugin/setting-up-env)
-* [Компонентная система сущностей (ECS)](./guides/ecs)
-* [Публикация вашего мода](./guides/publishing)
\ No newline at end of file
+* [Java Basics](./guides/java-basics/00-introduction)
+* [Setting up your dev environment](./guides/plugin/setting-up-env)
+* [Entity Component System (ECS)](./guides/ecs)
+* [Publishing your mod](./guides/publishing)
diff --git a/content/docs/sq-AL/contributing/index.mdx b/content/docs/sq-AL/contributing/index.mdx
new file mode 100644
index 00000000..ac05eb21
--- /dev/null
+++ b/content/docs/sq-AL/contributing/index.mdx
@@ -0,0 +1,39 @@
+---
+title: Contributing
+---
+
+# Contributing to HytaleModding
+
+We welcome contributions from the community to help improve and expand the HytaleModding documentation. Whether you're fixing typos, adding new tutorials, or providing code examples, your contributions are valuable!
+
+## How to Contribute
+
+### Reporting Issues
+
+If you've found a issue with the documentation, please report it by opening a new issue on our [GitHub repository](https://github.com/HytaleModding/site/issues).
+
+If you can work on this issue yourself, you can ask to be assigned to it and submit a PR.
+
+### Submitting Pull Requests
+
+1. Fork the repository on GitHub.
+2. Clone your fork to your local machine.
+3. Create a new branch for your changes.
+
+```bash
+git checkout -b my-feature-branch
+```
+
+4. Make your changes and commit them with clear messages. We follow [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/), your PR will not be accepted if your commit messages do not follow this convention.
+
+```bash
+git commit -m "Add feature X to documentation"
+```
+
+5. Push your changes to your fork.
+
+```bash
+git push origin my-feature-branch
+```
+
+6. Open a Pull Request on the original repository, describing your changes and why they should be merged.
diff --git a/content/docs/sq-AL/contributing/pr-guidelines.mdx b/content/docs/sq-AL/contributing/pr-guidelines.mdx
new file mode 100644
index 00000000..7a251032
--- /dev/null
+++ b/content/docs/sq-AL/contributing/pr-guidelines.mdx
@@ -0,0 +1,39 @@
+---
+title: PR Guidelines
+description: Guidelines that reviewers and contributors should follow when submitting and reviewing pull requests.
+---
+
+# Pull Request Guidelines
+
+To ensure a smooth and efficient review process, both contributors and reviewers should adhere to the following guidelines when submitting and reviewing pull requests (PRs).
+
+## For Contributors
+
+1. **Descriptive Titles and Descriptions**
+   - Use clear and concise titles that summarize the changes.
+   - Provide detailed descriptions of what the PR does, why the changes are necessary, and any relevant context.
+2. **Link to Issues**
+   - In your PR title, add `GH-ISSUE-NUMBER` to link the PR to the relevant issue. This is required for all PRs.
+3. **Small, Focused Changes**
+   - Aim to keep PRs small and focused on a single issue or feature. This makes it easier for reviewers to understand and provide feedback.
+4. **Code Quality**
+   - Ensure your code follows the project's coding standards and best practices.
+   - Include comments where necessary to explain complex logic.
+5. **Testing**
+   - Test your changes thoroughly before submitting the PR.
+   - If applicable, include unit tests or integration tests to verify your changes.
+6. **Documentation**
+   - Update or add documentation as needed to reflect your changes.
+7. **Commit Messages**
+   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
+8. **Check for Conflicts**
+   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+
+## For Reviewers
+
+- You are supposed to review PRs thoroughly, and request changes if needed.
+- Provide constructive feedback and suggestions for improvement.
+- Verify that the changes meet the project's coding standards and best practices.
+- Deploy the PR using the dokploy integration to ensure the changes work as expected.
+- Ensure that documentation is updated as necessary.
+- Approve the PR only when you are satisfied with the changes and all checks have passed.
diff --git a/content/docs/sq-AL/contributing/writing-guides.mdx b/content/docs/sq-AL/contributing/writing-guides.mdx
new file mode 100644
index 00000000..55c52ade
--- /dev/null
+++ b/content/docs/sq-AL/contributing/writing-guides.mdx
@@ -0,0 +1,86 @@
+---
+title: Writing Guides
+---
+
+## Creating a guide file
+
+To start writing a guide, you need to create a file with extension `.mdx`. You need to create this file inside the `/content/docs/en` directory, now it depends in which section you want to make the guide, so you can decide which folder you should put it in after that.
+
+Suppose I want to make a java basics guide, I'd put it in `/content/docs/en/guides/java-basics`. You'll have to do some digging to find out where you want to place it.
+
+<Callout>
+  If there's already a guide in the section you want to write about, you can just press on the "Edit On GitHub" button on our website and it'll take you to the folder, now you can write in the same folder to have your guide appear in the same section.
+</Callout>
+
+## Frontmatter
+
+Frontmatter is the metadata of your guide, it tells our website how to display your guide. This needs to be at the very top of the file, which starts with `---` and ends with `---`.
+
+Here's an example:
+
+```mdx
+---
+title: "Java Basics"
+description: "Learn the basics of Java programming."
+authors:
+    - name: "Your Name"
+      url: "https://yourwebsite.com"
+---
+```
+
+Now as you can see, it's pretty self explanatory, you just need to fill in the details for your specific guide. If you don't have a URL you want to link yourself to, just don't write that whole line. Additionally, the authors section is optional, so if you don't want to add it, you can just leave it out although we encourage you to do so and credit yourself.
+
+The indentation in the frontmatter is important, so make sure to keep it consistent with the example.
+
+## Content Structure
+
+You should structure the content of your guide in a clear and organized manner. Here are some tips on how to do that:
+
+- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
+- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
+- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
+- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
+- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+
+Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+
+When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+
+## Formatting
+
+We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+
+- Use headings (`#`, `##`, `###`) to organize your content.
+- Use bullet points and numbered lists for clarity.
+- Use code blocks (\`\`\`) for code snippets.
+- Use links to reference other guides or external resources.
+
+This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+
+You can also make a Callout to highlight important information or tips. Use the following syntax:
+
+```mdx
+<Callout>
+    This is a callout message.
+</Callout>
+```
+
+<Callout>
+  This is a callout message.
+</Callout>
+
+You can change the color of the callout by adding a `type` attribute. For example:
+
+```mdx
+<Callout type="info">
+    This is an info callout.
+</Callout>
+```
+
+Available types are: `info`, `warning`, `error`, and `success`.
+
+## Conclusion
+
+That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+
+Happy writing!
diff --git a/content/docs/sq-AL/established-information/client/index.mdx b/content/docs/sq-AL/established-information/client/index.mdx
new file mode 100644
index 00000000..39e863f6
--- /dev/null
+++ b/content/docs/sq-AL/established-information/client/index.mdx
@@ -0,0 +1,69 @@
+---
+title: The Hytale Client
+description: Information regarding the Hytale client.
+---
+
+<Callout>
+  The client is written in C#, compiled to machine code before distribution, and not moddable. Single-player runs on a local server. All mods must go through the server API.
+</Callout>
+
+# No Client-Side Mods
+
+There is no client-side modding.
+
+> We don't intend to support any client mods - Slikey
+
+## Why?
+
+1. No need to download externally.
+   * Hytale wants to "avoid a fragmented ecosystem where every server requires a different modded client".
+
+2. Client security.
+   * Running `.jar` files from third-party sites on the client can easily introduce malware.
+   > [We don't want to expose players] to the security and safety risks that exist on some other modding platform.
+
+3. Client stability.
+   * Hytale may move to other platforms on which client modding is impossible, so they're locking it down early to set the right direction early.
+   > We believe that the results that people get in other block games using client mods can be easily achieved using our server-sided modding. In other block games you have to install a client mod in order to get new blocks, NPCs, UI, etc.Hytale does all of that just by listening to the server. The server will basically "mod" the client temporarily in a really safe way to add and modify your gameplay experience. You could make your very own version of Orbis, using none of our models, music, world generation, combat or anything. You have control and you can rip it all out without ever touching the client. Think about how Roblox works.. You never change your App. You just click on an experience you want and you get all you need without modding your installation itself. - Slikey
+
+## Client Mods are Not Needed
+
+The typical use cases for client mods are:
+
+* Cosmetic changes (resource packs, shaders, capes, etc.): servers own visuals, not the client.
+* Performance: the base game will offer necessary performance controls.
+* Accessibility: the base game will be accessible on its own.
+* User Interface: servers own UI, not the client.
+
+### Client-Side Prediction
+
+Hytale uses data-driven client-side prediction to mitigate lag, as all interactions take place on the server and are relayed back to the client. This is already present for some systems but currently limited, though further integration is planned for the future. It's also planned to work with the visual scripting system in the future for further optimization.
+
+## Client-Side Execution
+
+The team is exploring allowing execution of code by the client (which is distinct from modding the client; this is code sent from the server), though this is not guaranteed.
+
+# Models
+
+The client and assets pipeline accepts `.blockymodel`, a custom format for Hytale. The official Blockbench plugin will allow you to export to this format.
+
+# Client Technical Details
+
+There will only ever be one current, supported version of the client.
+
+> Java version will be kept updated by us and right now we are on the latest version (Java 25)
+> The game version will not be selectable to avoid the version jungle we experienced on our hypixel server network. We simply want to make sure that multiplayer networks can rely on players having the latest version of the game to not have to support 15+ versions of the client. - Slikey
+
+The client is multithreaded.
+
+## GUI
+
+The GUI is built from C# bindings using Noesis.
+
+## Build System
+
+Hytale uses NativeAOT ("Ahead of Time") to build the client, which compiles C# to machine code for distribution. This means that, without reverse-engineering the machine code, mods will have to go through the server API.
+
+# Other Information
+
+The client has its own versioning and protocol to interact with servers.
diff --git a/content/docs/sq-AL/established-information/developer-qa-insights.mdx b/content/docs/sq-AL/established-information/developer-qa-insights.mdx
new file mode 100644
index 00000000..47915c97
--- /dev/null
+++ b/content/docs/sq-AL/established-information/developer-qa-insights.mdx
@@ -0,0 +1,125 @@
+---
+title: Developer Q&A Technical Insights
+description: Comprehensive summary of technical insights from Hytale developers covering architecture, modding, gameplay systems, and development philosophy.
+---
+
+# Developer Q&A Technical Insights
+
+This extensive Q&A session with Hytale developers reveals critical technical details about the game's architecture, modding philosophy, gameplay systems, and development approach.
+
+## Technical Architecture
+
+### Network & Infrastructure
+
+* **Protocol**: Uses QUIC (reliable UDP with unreliable channels) instead of TCP
+* **Server Compatibility**: Runs on any platform supporting Java 25
+* **Connection Method**: Direct IP initially, server discovery planned post-launch
+* **Data Layer**: Current custom serialization format will be replaced post-launch
+* **Performance**: Multi-core support - each world has main thread + parallel execution
+* **Rendering**: OpenGL 3.3 for Mac compatibility, potential future Vulkan/Metal migration
+* **Tick Model**: Base server tick rate is 30 TPS by default; can be changed using server plugins.
+
+### Security & Distribution
+
+* **No Client-Side Code Execution**: Prevents remote code execution exploits
+* **Downloads Limited To**: Configuration files and assets only
+* **Mod Distribution**: Community platforms (CurseForge, Modrinth), no immediate in-game marketplace
+* **Server Hosting**: Available day 1, no business agreements required (just EULA/TOS)
+
+## Modding Capabilities
+
+### Server-Side Power
+
+* **Full Java Access**: Database connections, web requests, any Java functionality
+* **Custom Libraries**: Can create Lua scripting, ML frameworks, or any Java library
+* **Server Modification**: Shared source code allows heavy server modifications
+* **Hot Reload**: Supported for most asset types
+* **Documentation**: Public GitBook planned, though initially sparse
+
+### Content Creation (No Code Required)
+
+* **World Generation**: Custom biomes and maps without Java
+* **NPCs & Items**: JSON-based configuration
+* **Crafting Recipes**: Data-driven system
+* **Visual Scripting**: Replaces command blocks, fully sandboxed
+* **Prefab System**: Sophisticated building blocks with in-game editor
+
+### Advanced Modding
+
+* **Combat System**: Data-driven interaction system for attack chains and abilities
+* **Sub-Hitboxes**: Support for complex boss mechanics (needs improvement)
+* **Status Effects**: Buff/debuff system with custom effects and stats
+* **Custom UI**: NoesisGUI transition enables powerful interface customization
+* **Block Physics**: Selective system (trees fall, but placed blocks don't)
+
+## Gameplay Systems
+
+### Core Mechanics
+
+* **Stamina System**: No hunger by default (can be modded in)
+* **Gravity**: Selective block physics - trees collapse, buildings can float
+* **Lighting**: Major overhaul to fix model/voxel inconsistencies
+* **World Height**: Currently limited, may change with voxel storage updates
+* **Automation**: No redstone equivalent at launch (moddable)
+
+### Player Systems
+
+* **Character Models**: Humans by default, changeable in creative mode
+* **Multiplayer Avatars**: Server-controlled (no custom models in multiplayer)
+* **Skins**: Full customization possible ("mod yourself into a potato")
+* **Shapeshifting**: Transformation potions exist for fun/modding
+
+### World & NPCs
+
+* **Faction System**: Living world with dynamic NPC interactions
+* **Village Systems**: Planned dynamic villages with relationships and behaviors
+* **Chunk Loading**: Entities unload when out of all players' render distance
+* **Seeds**: Shareable world generation seeds supported
+
+## Development Philosophy
+
+### Release Strategy
+
+* **Base Game Priority**: Adventure mode is primary focus, modding architecture supports it
+* **Tech Debt**: Acknowledged as necessary for release, commitment to improvement
+* **Update Frequency**: Very frequent updates planned, especially post-launch
+* **Version Policy**: Always latest version, but servers can run modified versions
+
+### Community Focus
+
+* **Creator Support**: Development bounties planned for community contributors
+* **Tutorials**: Official modding tutorials planned with partners
+* **Feedback Integration**: Strong commitment to community-driven improvements
+* **Accessibility**: Designed for lower-end hardware, reasonable system requirements
+
+### Tools & Documentation
+
+* **Blockbench Integration**: Replaces custom "Hytale Model Maker"
+* **Machinima Tools**: Full cinematic creation capabilities
+* **Creative Tools**: Major reveal planned for building/creation features
+* **Source Access**: Server code will be unobfuscated with developer comments
+
+## Platform Support
+
+* **Current**: Windows (primary)
+* **Planned**: Mac/Linux support actively in development
+* **VR**: Not feasible in near future
+* **Performance**: Uncapped framerate, designed for accessibility
+* **Offline Play**: Single-player works without internet connection
+
+## Monetization & Legal
+
+* **No Pay-to-Win**: Firm commitment against P2W mechanics
+* **Cosmetics Only**: Low-price cosmetic packs to support infrastructure
+* **Server EULA**: Terms being finalized for server monetization policies
+* **QUIC Blocking**: Acknowledged issue in some regions, no alternative protocol
+
+## Current Limitations
+
+* **Custom Shaders**: Not supported until sandboxing solution found
+* **UI/Input Limitations**: Being expanded but currently restricted
+* **Documentation**: Sparse initially, will improve over time
+* **Client Mods**: No client-side code execution for security
+* **Nameplates**: Currently limited customization
+
+This comprehensive technical foundation positions Hytale as a secure, extensible platform that empowers creators while maintaining performance, accessibility, and a commitment to continuous improvement.
diff --git a/content/docs/sq-AL/established-information/faq.mdx b/content/docs/sq-AL/established-information/faq.mdx
new file mode 100644
index 00000000..f9b651ef
--- /dev/null
+++ b/content/docs/sq-AL/established-information/faq.mdx
@@ -0,0 +1,45 @@
+---
+title: Frequently Asked Questions
+description: Frequently Asked Questions about Hytale modding.
+---
+
+On this page, we'll answer some of your Frequently Asked Questions.
+
+## 1. Can the client be modded?
+
+No, the client is not able to be modded, although the Client will not have control over how the game and the UI looks.
+
+The server decides the visuals, more like the "Resource Packs" available in Minecraft. The server decides what mods are used
+
+## 2. What Network Protocol will be used?
+
+Hytale will use the QUIC transport protocol.
+
+For context, the two main Internet protocols are UDP and TCP.
+
+* UDP is connectionless, fast, fire-and-forget packets but has less reliability as packets can be lost.
+* TCP is connection-based, slower than UDP, can guarantee packet delivery with much more reliability.
+  Both are pretty fast in modern times, games can run fine on both (but generally prefer UDP).
+
+QUIC is a **hybrid protocol** that builds off UDP to get the same speed benefits, but adds some layers of reliability like TCP.
+Essentially, a solid choice for game development that blends speed and reliability.
+
+## 3. What are Transfer Packets?
+
+Transfer packets in Hytale are small data payloads *(4kb)* that allow players to move from one server to another while carrying information.
+They are not equivalent to something like BungeeCord or Velocity and are primarily intended for smaller servers.
+
+Unlike BungeeCord, they do not manage network-wide features such as global plugins.
+Implementing DDOS protection would also be incredibly hard for smaller networks by using transfer packets.
+
+Transfer packets work quite well in scenarios such as small server networks or hubs where players will hop between servers without the loss of progress. For example, a player might finish a dungeon on one server and then move to a lobby or different game mode with their inventory and stats intact. This lessens server costs and enables the developers to put more effort into gameplay improvement rather than complicated network setups.
+
+## 4. Will Hytale support dedicated servers?
+
+Yes, Hytale will support dedicated servers. This allows server owners to host their own Hytale servers on their own hardware or through third-party hosting services.
+
+Dedicated servers provide more control over server settings, mods, and performance compared to using official hosting solutions.
+
+## 5. Will Hytale support modding on consoles?
+
+As of now, Hytale modding is primarily focused on PC platforms.
diff --git a/content/docs/sq-AL/established-information/gameplay/creative.mdx b/content/docs/sq-AL/established-information/gameplay/creative.mdx
new file mode 100644
index 00000000..c2c4e4b4
--- /dev/null
+++ b/content/docs/sq-AL/established-information/gameplay/creative.mdx
@@ -0,0 +1,243 @@
+---
+title: Creative
+description: Information regarding the creative mode in Hytale.
+---
+
+# Creative Mode
+
+Creative mode in Hytale is a sandbox mode that allows players to edit the world freely.
+
+## World Editing Tools
+
+Creative mode includes a variety of tools to help players edit the world. It includes undo functionality for edits.
+
+Note that the below sections were unnamed in the video demo of the tools.
+
+---
+
+### Laser Pointer
+
+Displays a ray from the player's camera in the direction the player is looking.
+
+#### Settings
+
+- Duration (Integer Slider): Description unknown as of December 2025.
+- Laser Color (Hex Color Code): Description unknown as of December 2025.
+
+### Sculpt Brush Tool
+
+Allows the user to raise and lower the terrain to more accurately sculpt and blend shapes. Supports most features of the Paint Brush.
+
+### Line Brush Tool
+
+Unknown as of December 2025.
+
+### Selection Tool
+
+Allows the user to select and edit regions of the world by transforming selections of blocks or a prefab via position, rotation, and extrusion.
+
+#### Settings
+
+- Mode (Combo Box: Set, Wall, Fill, Replace): Description unknown as of December 2025.
+- Material (Integer Slider): Description unknown as of December 2025.
+- Weight (Integer Slider): Description unknown as of December 2025.
+- Pitch (Integer): Description unknown as of December 2025.
+
+### Ruler
+
+Allows the user to measure distances between multiple points in 3D space, with support for multiple measurement lines and editing of measured points.
+
+### Layer Brush Tool
+
+Unknown as of December 2025.
+
+### Paste Tool
+
+Allows the user to paste a copied selection of blocks or a prefab at the point at which the player is looking. The paste is relative to the selection's anchor point. If the selection is a prefab, the anchor point may be set in the Prefab Editor. It is unknown if the selection's anchor may be set otherwise.
+
+### Flood Brush Tool
+
+Unknown as of December 2025.
+
+### Paint Brush Tool
+
+Brushes are used to make large changes to the world from far away.
+
+#### General Abilities
+
+- Place Shapes and Prefabs
+- Replace Blocks
+- Create Axis Locks and Masks
+
+#### Settings
+
+- Material
+- Width (Integer Slider): Description unknown as of December 2025.
+- Height (Integer Slider): Description unknown as of December 2025.
+- Shape (Combo Box: Cube, Sphere, Cylinder, Cone, Inverted Cone, Pyramid, Inverted Pyramid, Cuboid Grid): Description unknown as of December 2025.
+- Origin (Combo Box: Center, Bottom, Top): Description unknown as of December 2025.
+- Mirror Axis (Combo Box: None, Unknown other options): Description unknown as of December 2025.
+- Wall Thickness (Integer Slider): Description unknown as of December 2025.
+- Density (Integer Slider): Description unknown as of December 2025.
+
+#### Presets:
+
+- Boulder: Creates a boulder at the point at which the player is looking.
+- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
+- Rubble: Generate rubble at the point at which the player is looking.
+- Tentacle: TBD
+- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
+- Hot Springs: TBD
+- Ruins: Generates a ruin at the point at which the player is looking.
+- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
+- Grass: TBD
+- Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
+- Ruins: TBD
+
+---
+
+### Entity Grabber Tool
+
+Unknown as of December 2025.
+
+### Noise Brush Tool
+
+Unknown as of December 2025.
+
+### Scatter Brush Tool
+
+Unknown as of December 2025.
+
+### Extrude Brush Tool
+
+Unknown as of December 2025.
+
+### Prefab Selector Tool
+
+Allows the user to select a prefab when inside the Prefab Editor. May be used with the copy command.
+
+### Smooth Brush Tool
+
+Unknown as of December 2025.
+
+### Hitbox Tool
+
+Unknown as of December 2025.
+
+### Set Anchor Tool
+
+Allows the user to set an anchor point for a prefab when inside the Prefab Editor.
+
+### Tint Brush Tool
+
+Unknown as of December 2025.
+
+---
+
+## Creative Mode Quick Settings
+
+Note that these are WIP and subject to change. **Not all settings and functionality are currently known**.
+
+- Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
+- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
+- Brush Opacity (Integer Slider): Description unknown as of December 2025.
+- Selection Opacity (Integer Slider): Description unknown as of December 2025.
+- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
+- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
+- Display Legend (Toggle): Description unknown as of December 2025.
+- Show Tool Notifications (Toggle): Description unknown as of December 2025.
+- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
+- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
+- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
+- Flight Intertia (Integer Slider): Description unknown as of December 2025.
+- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
+- No Clip (Toggle): Description unknown as of December 2025.
+- Air Placement (Toggle): Description unknown as of December 2025.
+
+## Content Creation Tools
+
+Hytale includes a variety of built-in content creation tools to help players create and edit content.
+
+### Asset Editor
+
+Unknown as of December 2025.
+
+### Model Editor
+
+Unknown as of December 2025.
+
+### Asset Node Editor
+
+Unknown as of December 2025.
+
+### World Tools
+
+These are tools that allow the user to directly edit the current world.
+
+#### Prefab Editor
+
+Allows the user to create or edit prefabs in a separate space.
+
+##### Settings
+
+- Saved configs (Unknown type; presumably a file)
+- Root Dir (Unknown type; presumably a folder)
+- Prefab Paths or Folders (Unknown type; presumably a list of paths or folders)
+- Recursively Search for Prefabs (Toggle)
+- Spawn Entities and NPCs (Toggle)
+- Desired Y Level to Paste (Integer)
+- Blocks Between Prefabs (Integer)
+- WorldGen Type (Combo Box: Flat, Unknown other options): Description unknown as of December 2025.
+- (Flat WorldGen Only) Num Air Blocks Below Prefabs (Integer): Description unknown as of December 2025.
+- Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
+- Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
+
+#### Prefab List
+
+- Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
+- User can pick from server, assets, or worldgen prefabs.
+
+#### Spawn NPC
+
+Unknown as of December 2025.
+
+#### Spawn Particle
+
+Unknown as of December 2025.
+
+#### Change Player Model
+
+- Allows the player to change their model with an adjustable scale.
+
+#### Tint Chunk
+
+Unknown as of December 2025.
+
+#### Instances
+
+Unknown as of December 2025.
+
+### Builder Tools
+
+Unknown as of December 2025.
+
+### Machinima
+
+Machinima is a built-in sequence editor, allowing the user to create and edit sequences of actions to be played back in game. It includes a built-in interactive keyframe editor.
+
+The speed of playback can be adjusted via commands.
+
+The user may add actors for the sequence to control.
+
+- Reference
+- Camera
+- Entity
+- Item
+- Player
+
+## Commands
+
+Commands are entered into the world's chat console and begin with a forward slash `/`.
+
+- `set <block>`: allows the user to set the blocks in a selection to the specified block.
+- `inventory clear`: allows the user to clear their inventory.
diff --git a/content/docs/sq-AL/established-information/server-plugin-insights.mdx b/content/docs/sq-AL/established-information/server-plugin-insights.mdx
new file mode 100644
index 00000000..40c8ae52
--- /dev/null
+++ b/content/docs/sq-AL/established-information/server-plugin-insights.mdx
@@ -0,0 +1,93 @@
+---
+title: Server Code Insights
+description: Slikey shared some insights about server code on 12/15/2025. This document covers key points and takeaways from that discussion.
+---
+
+<Callout type="info" title="Note">
+  The following information is based on insights shared by Technical Director Slikey on December 15, 2025 on the Hytale Discord Server. It provides an overview of the server code architecture and plugin capabilities.
+
+  Majority of this document is just straight quotes from Slikey with minimal commentary. It is more over to preserve the information shared rather than reword it.
+</Callout>
+
+# Server Source Code
+
+The server will be released as shared source - we will have the source code with no obfuscation and all their comments.
+
+### License
+
+The license permits usage for any **hytale related** things, so as long as you dont use the server / source to make your own game or sell their algorithms.
+
+# Permission system
+
+After being asked in the Hytale Modding server, Lead Architect Zero has replied:
+
+It's quite basic, so don't expect much but yes we do have a permissions system built in. It also support implementing your own backend. Ex. if you wanted to store it in a database.
+
+![Premission Source Snippet](/assets/premission-system.png)
+
+# World Gen Implementation
+
+The following block of text is directly from Lead Architect Zero:
+
+You can totally implement a custom world gen in a plugin super easy. So if you want a totally different config or logic for generating terrain you can add that into a plugin and then configure a world to use that,
+We have some stuff load prefabs and there is existing code in the current world generators that could possibly be reused but no APIs specifically for the details of the generation itself.
+
+```java
+public interface IWorldGenProvider {
+    BuilderCodecMapCodec<IWorldGenProvider> CODEC = new BuilderCodecMapCodec<>("Type", true);
+
+    IWorldGen getGenerator() throws WorldGenLoadException;
+}
+```
+
+```java
+public interface IWorldGen {
+    @Nullable
+    WorldGenTimingsCollector getTimings();
+
+    CompletableFuture<GeneratedChunk> generate(int seed, long index, int x, int z, LongPredicate stillNeeded);
+
+    @Deprecated
+    Transform[] getSpawnPoints(int seed);
+
+    @Nonnull
+    default ISpawnProvider getDefaultSpawnProvider(int seed) {
+        return new FitToHeightMapSpawnProvider(new IndividualSpawnProvider(getSpawnPoints(seed)));
+    }
+
+    default void shutdown() {}
+}
+```
+
+# Server Code Snippets
+
+Some code snippets from a plugin they made were also shared. The following snippets are directly quoted from Technical Director Slikey:
+
+## BlockSpawner Plugin
+
+Alright, I'll drop some code snippets here for a simple plugin called "BlockSpawner" which will turn into a "random" block when put into the world based on the configured rules
+
+There is more code here in general but it shows the Asset System and the plugin layout. You can see that the asset system defines "Codecs" which are used to serialize and deserialize data. Using these codecs we can generate schemas.
+Let's say you connect to a server and open the asset editor: the server will send those schemas - so every single asset type defined server side, even you own, now become part of the asset editor on the client - no need to do anything, you just get to enjoy the editor UI for making your assets that you defined
+
+![Block Spawner Code 1](/assets/blockspawner-code-1.png)
+![Block Spawner Code 2](/assets/blockspawner-code-2.png)
+![Block Spawner Code 3](/assets/blockspawner-code-3.png)
+![Block Spawner Manifest](/assets/blockspawner-manifest.png)
+
+> i guess this part also shows a bit how we use constants to store some language keys - Slikey
+> (in reference to the image below)
+
+![Constants to store Language Keys](/assets/constants.png)
+
+> you can completely customize the chunk storage provider, we for example made one that is just empty where it doesnt load any chunks from disk
+> you could add an MySQLChunkStorageProvider and it could read the data from a database
+> and the same goes for worldgen, you can simply implement this interface to generate a world generator - slikey
+
+![Chunks 1](/assets/chunks-1.png)
+![Chunks 2](/assets/chunks-2.png)
+![Chunks 3](/assets/chunks-3.png)
+
+> i mean here are all the weapons defined, you tell me, obviously you will discover limitations but i think there is plenty of room to make changes - this stuff is actually hard though, there is a lot of QoL to have happen here
+
+![Weapons 1](/assets/weapons-1.png)
diff --git a/content/docs/sq-AL/established-information/server/content-categories/art-assets.mdx b/content/docs/sq-AL/established-information/server/content-categories/art-assets.mdx
new file mode 100644
index 00000000..39c2ed37
--- /dev/null
+++ b/content/docs/sq-AL/established-information/server/content-categories/art-assets.mdx
@@ -0,0 +1,123 @@
+---
+title: Modelling & Texturing / Art Assets
+description: Information about 3D Modelling, Texturing and Art Assets in Hytale.
+---
+
+# Modelling / Texture Art
+
+Hytale provides comprehensive support for 3D modeling and texture art creation, with specialized tools and workflows designed to maintain the game's distinctive visual style while empowering creators.
+
+## Current Mod Tooling
+
+### Blockbench
+
+Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
+
+* **Official support**: Used for "creating Hytale models, textures, and animations"
+* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
+* **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
+* **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
+
+## Model Constraints
+
+### Geometry Types
+
+The vast majority of models in Hytale are constrained to specific geometric primitives:
+
+**3D Elements**:
+
+* Blocks
+* Cuboids
+* Boxes
+
+**2D Elements**:
+
+* Quads
+* Rectangles
+* Planes (composed of 2 triangles)
+
+### Design Philosophy
+
+These constraints serve multiple purposes:
+
+* **Performance optimization**: Ensures efficient rendering and game performance
+* **Consistent art style**: Maintains Hytale's distinctive visual aesthetic
+* **Seamless integration**: Makes mods feel more cohesive with the base game
+
+## Pixel Density Standards
+
+Hytale uses different pixel densities for different types of content:
+
+### Standard Densities
+
+* **Blocks**: 32px density
+* **Player models**: 64px density
+* **Mobs**: Likely also 64px density
+* **Player equipment**: 64px density (weapons, cosmetics, armor, etc.)
+
+### Flexibility
+
+* **Wrong density handling**: Using incorrect density may cause assets to appear at the wrong size, but will not cause import failures
+* **No strict restrictions**: Pixel ratio, rotation, and scaling are not restricted
+* **Forgiving system**: The tools are designed to be flexible while maintaining compatibility
+
+## Hytale Asset Editor
+
+### In-Game Editor
+
+The Asset Editor is a comprehensive tool that will ship with the game:
+
+* **Ships with game**: Available to all players from launch
+* **External tool requirement**: Does not support image editing, you must use external tools for texture creation
+* **Data asset editing**: Primary editor for working with Data Assets
+* **Expanding capabilities**: Currently supports most features, though has limitations around NPCs, worldgen, and interactions that will expand over time
+
+### Particle Creation
+
+The Asset Editor includes robust particle creation tools:
+
+* **In-game creation**: Particles are created directly in-game using the Asset Editor
+* **Industry standard**: Particle logic is robust and similar to Unity/Unreal particle systems
+* **Event-driven**: Particles can be spawned on events or interactions (like opening doors)
+* **Entity attachment**: Can attach particles to entities with specific attachment points
+* **Dynamic movement**: Supports particles moving with their anchor points
+* **Time delays**: Supports time-based particle effects and delays
+
+## Materials
+
+### Optimization Focus
+
+Hytale takes a different approach to materials compared to other engines:
+
+* **Pre-optimized**: Materials are very optimized and artists cannot create custom materials
+* **Performance priority**: This constraint ensures consistent performance across all content
+* **Curated system**: Maintains visual consistency while maximizing efficiency
+
+## Best Practices
+
+### Asset Optimization
+
+Key considerations from Hytale's development team:
+
+* **Mindful resource usage**: Be conscious of how many blocks/quads you use and texture file sizes
+* **Avoid bloat**: Goal is to prevent unnecessary asset bloat that could impact performance
+* **Efficiency focus**: Balance visual quality with technical constraints
+
+### Future Documentation
+
+* **Best practice guide**: A comprehensive "best practice" guide for art and modeling will be released at some point
+* **Flexible boundaries**: Most creative goals can be achieved without breaking anything in the system
+* **Community-driven workflows**: Tools are designed to support established creative workflows in the modding community
+
+## Integration with Development Pipeline
+
+The modeling and texture art workflow integrates seamlessly with Hytale's broader development ecosystem:
+
+* **Asset Editor compatibility**: Models created in Blockbench work directly with the Hytale Asset Editor
+* **Data Asset integration**: 3D models can be configured and customized through Data Assets
+* **Visual Scripting support**: Models can be controlled and animated through Visual Scripting
+* **Java plugin extensibility**: Advanced model behaviors can be implemented through Java plugins
+* **Particle integration**: Models can have particles attached at specific points for enhanced visual effects
+
+This integrated approach ensures that 3D modeling and texture art aren't isolated creative processes, but core components of Hytale's comprehensive development environment.
diff --git a/content/docs/sq-AL/established-information/server/content-categories/data-assets.mdx b/content/docs/sq-AL/established-information/server/content-categories/data-assets.mdx
new file mode 100644
index 00000000..1c11ef23
--- /dev/null
+++ b/content/docs/sq-AL/established-information/server/content-categories/data-assets.mdx
@@ -0,0 +1,61 @@
+---
+title: Data Assets
+description: Information about data assets in Hytale and how they drive gameplay behavior and content creation.
+---
+
+# Data Assets
+
+Data Assets are JSON files which drive gameplay behavior and core content in Hytale. They provide a powerful, data-driven approach to creating and modifying game elements without needing to write code.
+
+## What Are Data Assets?
+
+Data Assets allow you to create or modify fundamental game elements through JSON configuration files:
+
+* **Blocks**: Define new block types and their properties
+* **Items**: Create custom items with unique behaviors
+* **NPCs**: Configure non-player characters and their AI
+* **World generation**: Control how the world is generated
+* **Loot tables**: Define what items drop from various sources
+
+## Comparison to Minecraft
+
+Data Assets are analogous to Minecraft's data pack JSON files, but with significantly broader scope. While Minecraft's data packs are somewhat limited, Hytale's data-driven architecture means that core game elements like blocks, items, and NPCs can all be modified through JSON files.
+
+This expanded data-driven approach gives modders much more power to customize the game without needing to dive into complex programming.
+
+## Development Tools
+
+Recognizing that JSON editing can be tedious and error-prone when done by hand, Hytale plans to provide multiple tools to make working with Data Assets more accessible:
+
+### Node Editor
+
+Hytale is developing a "Node Editor" to make Data Asset management more user-friendly:
+
+* **Visual interface**: Provides a graphical way to work with data relationships
+* **Customization focus**: Particularly helpful for customizing NPCs, interactions, and world generation
+* **Integrated workflow**: Works directly within the Hytale Asset Editor for a unified creator suite
+* **Accessibility**: Makes complex data relationships easier to understand and modify
+
+### Additional Tools
+
+Beyond the Node Editor, Hytale plans to support:
+
+* **Visual JSON generators**: Graphical interfaces for creating JSON without writing syntax
+* **Form-based editors**: Structured forms that generate the appropriate JSON automatically
+* **Multiple workflow options**: Different tools for different comfort levels and use cases
+
+## Power and Simplicity
+
+The effectiveness of Data Assets is demonstrated by their simplicity. For example, making raptors rideable in Hytale reportedly requires only 4 lines of JSON configuration - showcasing how powerful yet accessible the system is designed to be.
+
+This balance between power and accessibility is central to Hytale's modding philosophy: providing professional-grade tools that don't require programming expertise to use effectively.
+
+## Integration with Other Systems
+
+Data Assets work seamlessly with Hytale's other development approaches:
+
+* **Visual Scripting**: Can reference and manipulate data defined in Data Assets
+* **Java plugins**: Can read from and modify Data Assets for more complex behaviors
+* **Asset Editor**: Provides a unified interface for managing both visual assets and their data configurations
+
+This integration ensures that Data Assets aren't isolated configuration files, but rather a core part of Hytale's comprehensive development environment.
diff --git a/content/docs/sq-AL/established-information/server/content-categories/plugin.mdx b/content/docs/sq-AL/established-information/server/content-categories/plugin.mdx
new file mode 100644
index 00000000..5b585924
--- /dev/null
+++ b/content/docs/sq-AL/established-information/server/content-categories/plugin.mdx
@@ -0,0 +1,48 @@
+---
+title: Java Modding (Server Plugins)
+description: An introduction to what we know of Hytale's Java-based modding system as of writing this article.
+---
+
+Hytale's modding capabilities include a Java-based modding system that allows modders
+to create custom behaviors, interactions, and game mechanics. While the full details of
+this system are not publicly documented as the game is still in development and not
+released, we can summarize what is currently known about it.
+
+### Important Details of Modding in Hytale
+
+Hytale's modding goes on server side and not client side, meaning that mods/plugins are
+hosted on the server and players connect to these modded servers to experience the custom content
+without needing to install anything on their end. This approach ensures a consistent experience
+for all players on a modded server.
+
+### Overview of Java-Based Modding
+
+The server-side modding system in Hytale is based on Java, making the server plugins JAR files.
+
+We're guessing this is done so that Minecraft modders can easily transition to Hytale modding,
+as Minecraft modding is also primarily Java-based. This allows modders familiar with Java
+to leverage their existing knowledge when creating mods for Hytale.
+
+#### Singleplayer Concerns
+
+Despite the name, server plugins can also be used in singleplayer mode.
+Hytale's singleplayer mode runs a local server instance, allowing players to use server plugins
+even when playing alone. This means that mods created as server plugins can enhance the singleplayer experience as well.
+
+### Mixin System
+
+Mixins were used in Minecraft modding to directly modify the game’s code, even able to overwrite
+or redirect logic and values. An extremely powerful but somewhat brittle system which depends
+on the source code/game version staying pretty much the same.
+
+We have no official information on Mixins in Hytale. Despite that, we have reason to believe they will not
+need to be supported for the following reasons:
+
+1. For a properly designed game, 95% of Mixin use cases can be solved with a good API instead.
+   In fact, many Minecraft modding APIs simply mixin to provide the API so the developers using
+   those APIs don’t have to write the mixin themselves.
+   * This is typically replacing hardcoded values and overwriting hardcoded behaviors.
+   * Hytale should ideally make these both API or data-driven.
+2. APIs can also be much more resilient than the game version. We can have a separate API
+   version system which means the same code will not need to be modified across multiple updates
+   until the API changes in a breaking way.
diff --git a/content/docs/sq-AL/established-information/server/content-categories/visual-scripting.mdx b/content/docs/sq-AL/established-information/server/content-categories/visual-scripting.mdx
new file mode 100644
index 00000000..16cb0508
--- /dev/null
+++ b/content/docs/sq-AL/established-information/server/content-categories/visual-scripting.mdx
@@ -0,0 +1,59 @@
+---
+title: Visual Scripting
+description: An introduction to what we know of Hytale's visual scripting system as of writing this.
+---
+
+# Visual Scripting
+
+Hytale plans to support Visual Scripting as a method to make advanced logic and control flow accessible to a wider audience. This system will not be available at launch, but should be available shortly after launch.
+
+## Overview
+
+Visual Scripting in Hytale is designed to function similarly to Blueprints in Unreal Engine. It allows designers to create complex behaviors through a visual interface that matches how they think about game logic, without needing to write code directly.
+
+### Key Features
+
+* **Subset of Java functionality**: Visual Scripting can do a subset of what is possible with Java plugins
+* **Designer-friendly**: "Designers are empowered through a visual language that matches how they think about behaviors"
+* **Programmer extensible**: Programmers can extend and optimize the system by adding new visual nodes and performance-sensitive implementations
+* **Safe sharing environment**: Provides a sandboxed, safe environment for sharing logic between modders
+
+## Advantages Over Traditional Coding
+
+Visual Scripting makes writing custom logic more accessible by removing common hurdles found when developing in Java:
+
+* **No complex environment setup**: No need to worry about installing the right tools or configuring development environments
+* **Syntax-free development**: Removes the need to learn and remember programming syntax
+* **Safer sharing**: Malware in visual scripting should be virtually impossible
+* **More inclusive**: Lowers the barrier to entry for non-programmers
+
+## Relationship with Java
+
+Visual Scripting and Java plugins are designed to work in tandem:
+
+* **Java extends Visual Scripting**: Programmers can create new visual nodes using Java
+* **Performance optimization**: While Visual Scripting may not be as optimized as Java directly, programmers can implement performance-critical logic in Java and expose it as visual nodes
+* **Best of both worlds**: Allows the majority of logic to remain in the accessible Visual Scripting environment while keeping expensive operations optimized
+
+Hytale strongly recommends Visual Scripting since it is both more accessible and safer to share and download. However, staying purely in Java will still work for those who prefer it.
+
+## 3D Visual Scripting
+
+One of Hytale's unique features is bringing visual scripting directly into the 3D world:
+
+* **In-world editing**: Link levers, doors, spawners, triggers, and other elements directly inside the game
+* **Adventure map creation**: Excellent for building adventure maps and encounters without leaving Hytale
+* **Similar to DOOM SnapMap**: Provides a familiar workflow for those who have used similar systems
+* **Fully integrated**: Works seamlessly with the asset and scripting stack
+
+## No Text-Based Scripting
+
+Hytale has made a deliberate decision not to include text-based scripting languages. Their reasoning:
+
+* **False compromise**: Text-based scripting is often introduced to "help non-programmers" but still requires learning programming concepts
+* **Complexity increase**: Programmers end up juggling two languages where one is less powerful
+* **Still requires syntax**: Designers still need to learn syntax and programming concepts
+* **Less inclusive**: Doesn't truly solve the accessibility problem
+* **Fragmentation**: Avoids "fragmenting logic across multiple 'half-languages'"
+
+Instead, Hytale believes visual scripting is a better approach that truly makes game logic accessible to a wider audience while maintaining the power and flexibility needed
diff --git a/content/docs/sq-AL/established-information/server/interface/inputs.mdx b/content/docs/sq-AL/established-information/server/interface/inputs.mdx
new file mode 100644
index 00000000..b6b3ff3b
--- /dev/null
+++ b/content/docs/sq-AL/established-information/server/interface/inputs.mdx
@@ -0,0 +1,16 @@
+---
+title: Inputs
+description: Information about input methods supported in Hytale.
+---
+
+Hytale is designed to support a variety of input methods to accommodate different player preferences and platforms.
+
+## Interaction System
+
+Hytale features a robust interaction system that allows plugins to customize how keybinds are interpreted and what actions they trigger. This system is data-driven, enabling modders to create complex interactions through assets.
+
+Modders can define custom keybinds for various actions, such as using abilities or interacting with objects in the game world. The interaction system is designed to be powerful, though it may require some effort to manage the complexity of the assets involved.
+
+> You can use your own interactions to use keybinds for whatever you want. Interaction system is very powerful but we still need to work on its usability as the assets can become quite complex and hard to handle
+
+\- [slikey](https://discord.com/channels/523059903812599811/1428794280868184064/1441291391065129103)
diff --git a/content/docs/sq-AL/established-information/server/interface/ui-customization.mdx b/content/docs/sq-AL/established-information/server/interface/ui-customization.mdx
new file mode 100644
index 00000000..d2acbd6b
--- /dev/null
+++ b/content/docs/sq-AL/established-information/server/interface/ui-customization.mdx
@@ -0,0 +1,80 @@
+---
+title: UI Customization
+description: Information about UI customization in Hytale.
+---
+
+UI can be customized via **server-side** modding. Many of the UI pages shown to players are available to be modified by server owners through mods.
+
+## UI Customization in Hytale
+
+Hytale provides extensive UI customization capabilities through server-side modding, allowing server owners to modify many of the UI pages that players interact with.
+
+### Control Flow
+
+The UI system in Hytale follows a specific control flow pattern:
+
+1. Server sends UI data to the client
+2. Client renders the UI
+3. User interacts with the UI (e.g., pressing a button)
+4. Client sends the interaction event to the server
+5. Server executes the callback logic for the event
+
+This architecture means:
+
+* The client is responsible for rendering UI and sending user interactions to the server
+* The server handles all the actual logic behind user interactions
+
+<Callout type="warning" title="Possible Performance Implications">
+  <span>
+    Because the server processes all UI logic, there is an inherent latency
+    impact on UI responsiveness. Button clicks and other interactions must
+    travel to the server before taking effect, meaning network ping directly
+    affects UI responsiveness.
+  </span>
+
+  <span>
+    Additionally, since client-side modding is not supported, no modded values
+    persist on the client.
+  </span>
+</Callout>
+
+### UI Layout Assets
+
+Hytale's UI customization system works through the following structure:
+
+* **UI Layout**: Sent to the client as an asset
+* **UI Behavior**: Defined in Java code
+* **Custom Layouts**: Enables creation of bespoke UI layouts rather than repurposing existing ones (unlike inventory menu modifications in Minecraft)
+
+### UI Framework Implementations
+
+Hytale currently supports multiple UI implementations, with plans to consolidate on NoesisGUI:
+
+#### Legacy Implementation
+
+* Serves as an example of server modding capabilities
+* Uses a combination of in-game elements, UI Markup Assets, and Java mod code
+* Utilizes a legacy custom markup language
+* Will be deprecated in favor of NoesisGUI
+
+#### NoesisGUI (Primary Framework)
+
+* Uses XAML Markup Language for UI definition
+* Supports multiple languages for internationalization
+* Runs on C# bindings on the client side (not C++)
+* Represents the future direction of Hytale's UI system
+
+#### Third Framework
+
+* Currently being phased out
+* Will be replaced by NoesisGUI as part of the consolidation effort
+
+### Performance Considerations
+
+Due to the server-side nature of UI processing, there are inherent performance characteristics to consider:
+
+* **Latency Impact**: Button clicks and UI interactions must travel to the server before taking effect, meaning network ping directly affects UI responsiveness
+* **No Client Persistence**: Since client-side modding is not supported, no modded values persist on the client
+* **Optimized Architecture**: Hytale's system is designed to minimize latency through efficient communication protocols and optimized server performance, ensuring smooth interactions despite server-side processing requirements
+
+The architecture prioritizes security and consistency by centralizing UI logic on the server while maintaining responsive user experiences
diff --git a/content/docs/sq-AL/established-information/server/server-first-dev.mdx b/content/docs/sq-AL/established-information/server/server-first-dev.mdx
new file mode 100644
index 00000000..1ed97a61
--- /dev/null
+++ b/content/docs/sq-AL/established-information/server/server-first-dev.mdx
@@ -0,0 +1,29 @@
+---
+title: Server-First Development
+description: Information regarding what Server-First Development means, and more.
+---
+
+Hytale is being developed with a "server-first" approach. This means that the server is considered the authoritative source of game state and logic, while the client primarily handles rendering and user input.
+
+## What does "Server-First" mean?
+
+In a server-first architecture, the server is responsible for managing the game world, enforcing rules, and processing player actions. The client connects to the server to receive updates about the game state and to send player inputs. This approach helps ensure consistency and fairness in multiplayer environments, as the server has control over the game logic.
+
+## Benefits of Server-First Development
+
+* **Consistency**: Since the server is the authoritative source, all players experience the same game state, reducing discrepancies and cheating.
+* **Scalability**: Server-first architectures can be more easily scaled to accommodate large numbers
+  of players, as the server can manage resources and distribute load effectively.
+* **Security**: By centralizing game logic on the server, it becomes more difficult for players to manipulate the game state unfairly.
+* **Easier Updates**: Updates and changes can be made on the server side without requiring players to download new client versions.
+* **Only One Version**: There won't be a version selector for the Hytale Client, meaning that server owners do not need to support multiple versions and can rely on everyone being on the latest client. This will help both server owners and modders.
+
+## Implications for Modding
+
+Modders will primarily interact with the server-side components of Hytale. This means that mods will often focus on altering game logic, rules, and behaviors that are managed by the server. Client-side modifications are not allowed (as of the information given right now).
+
+Overall, the server-first approach in Hytale aims to create a robust and fair multiplayer experience while providing modders with powerful tools to customize and enhance the game.
+
+## Conclusion
+
+The server-first development model is a key aspect of Hytale's architecture, ensuring a consistent and secure multiplayer experience. Modders should focus on server-side modifications to fully leverage the capabilities of this approach and create engaging content for players.
diff --git a/content/docs/sq-AL/guides/ecs/entity-component-system.mdx b/content/docs/sq-AL/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/sq-AL/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/sq-AL/guides/ecs/example-ecs-plugin.mdx b/content/docs/sq-AL/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/sq-AL/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/sq-AL/guides/ecs/hytale-ecs-theory.mdx b/content/docs/sq-AL/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/sq-AL/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/sq-AL/guides/ecs/systems.mdx b/content/docs/sq-AL/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/sq-AL/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/sq-AL/guides/java-basics/00-introduction.mdx b/content/docs/sq-AL/guides/java-basics/00-introduction.mdx
new file mode 100644
index 00000000..a03ad638
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/00-introduction.mdx
@@ -0,0 +1,52 @@
+---
+title: 00 - Introduction to Java
+description: A beginner's guide to understanding the fundamentals of Java programming for Hytale modding.
+---
+
+Welcome to your journey into Java Programming! This guide is designed to introduce you into the basics of java.
+
+## What is Java?
+
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+
+## What You'll Learn
+
+This guide is structured to take you step-by-step through:
+
+1. Java Syntax and Basics
+2. Control Flow
+3. Object-Oriented Programming
+
+We will then focus on only Hytale-specific concepts. (tbd)
+
+## Setting up your Environment
+
+Before we dive into programming, you'll need some essentials, you need to install:
+
+### Java Development Kit (JDK)
+
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+
+### Integrated Development Environment (IDE)
+
+An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
+
+* [IntelliJ IDEA](https://www.jetbrains.com/idea/)
+* [Eclipse](https://www.eclipse.org/)
+
+## How to Use This Guide
+
+1. Read each article in order - Concepts build on each other
+2. Type out the examples - Don't copy-paste; typing helps you learn
+3. Experiment - Modify examples to see what happens
+4. Practice - Each article includes exercises
+5. Be patient - Programming is a skill that takes time to develop
+
+## The Modding Mindset
+
+Modding is creative problem-solving. You'll be:
+
+* Adding new blocks, items, and creatures to Hytale
+* Changing game mechanics to create unique experiences
+* Building systems that interact with the game world
+* Sharing your creations with the community
diff --git a/content/docs/sq-AL/guides/java-basics/01-variables.mdx b/content/docs/sq-AL/guides/java-basics/01-variables.mdx
new file mode 100644
index 00000000..f884cc02
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/01-variables.mdx
@@ -0,0 +1,77 @@
+---
+title: 01 - Variables & Data Types
+description: An introduction to variables and data types in Java programming.
+---
+
+Variables are containers that store data in your program. Think of them as labeled boxes where you can put different types of information.
+
+## What is a Variable?
+
+A variable has three key components:
+
+1. **Type**: What kind of data it holds (e.g., integer, string, boolean)
+2. **Name**: The label you use to refer to the variable
+3. **Value**: The data it contains
+
+## Declaring/Creating Variables
+
+In Java, you must declare a variable before using it, like you'd need a box before putting something in it. The syntax is:
+
+```java
+int age; // A declaration
+age = 18; // An assignment
+
+int age = 18; // Declaration and assignment in one line, also considered an initialization
+```
+
+## Primitive Data Types
+
+You might wonder what "int" means. It's a primitive data type in Java. Java has 8 primitive data types. Here are the most important ones for modding:
+
+| Data Type | Description                   | Example                    |
+| --------- | ----------------------------- | -------------------------- |
+| int       | Integer (whole numbers)       | `int score = 100;`         |
+| double    | Decimal numbers               | `double pi = 3.14;`        |
+| boolean   | True or false values          | `boolean isActive = true;` |
+| char      | Single character              | `char grade = 'A';`        |
+| String    | Sequence of characters (text) | `String name = "Hytale";`  |
+
+## Type Conversion
+
+Sometimes you might not want a variable to stay the same type. You can convert between types:
+
+### Automatic
+
+```java
+int num = 10;
+double decimalNum = num; // 10.0 - works automatically
+```
+
+### Manual (Casting)
+
+```java
+double decimalNum = 9.78;
+int num = (int) decimalNum; // 9 - decimals are dropped
+```
+
+## Constants
+
+If you want a variable that shouldn't change, use the `final` keyword:
+
+```java
+final double PI = 3.14159;
+```
+
+**Convention**: Constants use ALL_CAPS_WITH_UNDERSCORES.
+
+## Practice
+
+It's best to practice what you just learnt - don't look above now and try to do this yourself. If you get stuck, look back up!
+
+1. Declare an integer variable named `lives` and set it to 3.
+2. Declare a double variable named `gravity` and set it to 9.81.
+3. Declare a boolean variable named `isGameOver` and set it to false.
+4. Convert the `lives` variable to a double and store it in a new variable named `livesAsDouble`.
+5. Declare a constant named `MAX_LEVEL` and set it to 100.
+
+Great! You've learned about variables and data types in Java. Now we're going to learn about operators and expressions in the next lesson.
diff --git a/content/docs/sq-AL/guides/java-basics/02-operators.mdx b/content/docs/sq-AL/guides/java-basics/02-operators.mdx
new file mode 100644
index 00000000..a132b1c0
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/02-operators.mdx
@@ -0,0 +1,128 @@
+---
+title: 02 - Operators and Expressions
+description: An introduction to operators and expressions in Java programming.
+---
+
+Operators are symbols that perform operations on variables and values. They're the verbs of programming - they make things happen!
+
+## Arithmetic Operators
+
+Used for mathematical calculations:
+
+```java
+int a = 10;
+int b = 5;
+
+int sum = a + b;        // Addition: 15
+int difference = a - b; // Subtraction: 5
+int product = a * b;    // Multiplication: 50
+int quotient = a / b;   // Division: 2
+int remainder = a % b;  // Modulus (remainder): 0
+```
+
+<Callout type="info" title="Division Note">
+  When dividing integers, Java performs integer division, which means it discards any decimal part. For example, `7 / 2` would result in `3`, not `3.5`.
+
+  ```java
+  int x = 7 / 2;       // 3 (not 3.5!) - Integer division
+  double y = 7.0 / 2;  // 3.5 - At least one double gives double result
+  double z = (double) 7 / 2;  // 3.5 - Casting works too
+  ```
+</Callout>
+
+### Modulus (%) - The remainder Operator
+
+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)
+```
+
+## Compound Assignment Operators
+
+These operators combine an arithmetic operation with assignment:
+
+```java
+int a = 10;
+
+a = a + 5;  // The old way
+
+a += 5;     // a = a + 5
+a -= 3;     // a = a - 3
+a *= 2;     // a = a * 2
+a /= 4;     // a = a / 4
+a %= 3;     // a = a % 3
+```
+
+## Increment and Decrement Operators
+
+Used to increase or decrease a variable's value by 1:
+
+```java
+int a = 5;
+a++; // Increment: a becomes 6
+a--; // Decrement: a becomes 5 again
+```
+
+<Callout type="info" title="Prefix vs Postfix">
+  ```java
+  int a = 5;
+  int b = a++; // b is 5, a is now 6
+  int c = ++a; // a is 7, c is now 7
+  ```
+</Callout>
+
+## Comparison Operators
+
+Used to compare two values, returning a boolean result (`true` or `false`):
+
+```java
+int a = 10;
+int b = 5;
+
+a == b // false - Equal to
+a != b // true  - Not equal to
+a > b  // true  - Greater than
+a < b  // false - Less than
+a >= b // true  - Greater than or equal to
+a <= b // false - Less than or equal to
+```
+
+## Logical Operators
+
+Used to combine multiple boolean expressions:
+
+```java
+boolean x = true;
+boolean y = false;
+
+x && y // false - Logical AND
+x || y // true  - Logical OR
+!x     // false - Logical NOT
+```
+
+### Combining Logical Operators
+
+```java
+boolean result = (a > b) && (b < 10); // true if both conditions are true
+```
+
+## String Concatenation
+
+The `+` operator can also be used to concatenate (join) strings:
+
+```java
+String greeting = "Hello, " + "world!"; // "Hello, world!"
+String name = "Alice";
+String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
+```
+
+## Operator Precedence
+
+Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+
+```java
+int result = 10 + 5 * 2; // result is 20, not 30
+```
+
+{/* practice to be added */}
diff --git a/content/docs/sq-AL/guides/java-basics/03-control-flow-if.mdx b/content/docs/sq-AL/guides/java-basics/03-control-flow-if.mdx
new file mode 100644
index 00000000..b9d6c479
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/03-control-flow-if.mdx
@@ -0,0 +1,128 @@
+---
+title: 03 - Control Flow If Statements
+description: Learn how to control the flow of your Java programs using if statements.
+---
+
+Programs need to make decisions. If statements let your code choose different paths based on conditions.
+
+## Basic If Statement
+
+The simplest form checks one condition;
+
+```java
+int health = 20;
+
+if (health > 10) {
+    System.out.println("You are healthy!");
+}
+```
+
+### Structure
+
+```java
+if (condition) {
+    // code to execute if condition is true
+}
+```
+
+## If-Else Statements
+
+Choose between two paths:
+
+```java
+int health = 5;
+
+if (health > 10) {
+    System.out.println("You are healthy!");
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## If-Else Else-If Chain
+
+Check multiple conditions in sequence:
+
+```java
+
+int health = 7;
+
+if (health > 15) {
+    System.out.println("You are in great shape!");
+} else if (health > 5) {
+    System.out.println("You are okay.");
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## Nested If Statements
+
+You can place if statements inside other if statements:
+
+```java
+int health = 12;
+
+if (health > 10) {
+    if (health > 15) {
+        System.out.println("You are in great shape!");
+    } else {
+        System.out.println("You are healthy!");
+    }
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## Compound Conditions
+
+You can combine multiple conditions using logical operators:
+
+```java
+
+// AND - both must be true
+int health = 12;
+boolean hasPotion = true;
+
+if (health > 10 && hasPotion) {
+    System.out.println("You are healthy and have a potion!");
+} else if (health > 10) {
+    System.out.println("You are healthy but need a potion!");
+} else {
+    System.out.println("You need healing!");
+}
+
+// OR - at least one must be true
+
+int health = 8;
+boolean hasPotion = false;
+if (health > 10 || hasPotion) {
+    System.out.println("You are either healthy or have a potion!");
+} else {
+    System.out.println("You need healing and a potion!");
+}
+
+// NOT - reverses the condition
+
+int health = 8;
+if (!(health > 10)) {
+    System.out.println("You need healing!");
+} else {
+    System.out.println("You are healthy!");
+}
+```
+
+## Ternary Operator
+
+A compact way to assign values:
+
+```java
+int health = 12;
+String status = (health > 10) ? "Healthy" : "Needs Healing";
+```
+
+### Syntax
+
+```java
+variable = (condition) ? valueIfTrue : valueIfFalse;
+```
diff --git a/content/docs/sq-AL/guides/java-basics/04-control-flow-loops.mdx b/content/docs/sq-AL/guides/java-basics/04-control-flow-loops.mdx
new file mode 100644
index 00000000..8ff5b509
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/04-control-flow-loops.mdx
@@ -0,0 +1,165 @@
+---
+title: 04 - Control Flow Loops
+description: Learn how to repeat code efficiently using loops in Java
+---
+
+Loops let you repeat code without writing it over and over. They're essential for processing collections, generating worlds, and updating game objects.
+
+## While Loop
+
+Repeats code while a condition is true:
+
+```java tab="Code"
+
+int countdown = 5;
+
+while (countdown > 0) {
+    System.out.println(countdown);
+    countdown--;
+}
+System.out.println("Blast off!");
+```
+
+```java tab="Output"
+5
+4
+3
+2
+1
+Blast off!
+```
+
+### Structure
+
+```java
+while (condition) {
+    // code to repeat
+}
+```
+
+<Callout type="warning" title="Infinite Loops">
+  Always make sure your loop condition will eventually become false, or your program will run forever!
+
+  ```java tab="Bad Example"
+  int x = 0;
+  while (x < 10) {
+      System.out.println("Stuck!");
+      // Forgot to increase x!
+  }
+  ```
+
+  ```java tab="Good Example"
+  int x = 0;
+  while (x < 10) {
+      System.out.println("Counting: " + x);
+      x++; // This increases x! // [!code ++]
+  }
+  ```
+</Callout>
+
+## Do-While Loop
+
+Like a while loop, but always runs at least once:
+
+```java
+int health = 0;
+
+do {
+    System.out.println("Attempting respawn...");
+    health = 100;
+} while (health <= 0);
+```
+
+## For Loop
+
+Best when you know how many times to repeat:
+
+```java tab="Code"
+for (int i = 1; i <= 5; i++) {
+    System.out.println("Level " + i);
+}
+```
+
+```java tab="Output"
+Level 1
+Level 2
+Level 3
+Level 4
+Level 5
+```
+
+### Structure
+
+```java
+for (initialization; condition; update) {
+    // code to repeat
+}
+```
+
+<Callout type="info" title="For Loop Parts">
+  ```java
+  for (int i = 0; i < 10; i++) {
+  //   ^         ^        ^
+  //   Start     Stop     Step
+  }
+  ```
+
+  * **Initialization**: int i = 0 - Runs once at the start
+  * **Condition**: i < 10 - Checked before each loop
+  * **Update**: i++ - Runs after each loop
+</Callout>
+
+## Break Statement
+
+You can exit a loop early with `break`:
+
+```java
+
+for (int i = 1; i <= 10; i++) {
+    if (i == 6) {
+        break; // Exit loop when i is 6
+    }
+    System.out.println(i);
+}
+
+```
+
+## Continue Statement
+
+Skip to the next iteration with `continue`:
+
+```java
+for (int i = 1; i <= 10; i++) {
+    if (i % 2 == 0) {
+        continue; // Skip even numbers
+    }
+    System.out.println(i); // Prints only odd numbers
+}
+```
+
+## Nested Loops
+
+You can put loops inside other loops:
+
+```java
+for (int i = 1; i <= 3; i++) {
+    for (int j = 1; j <= 2; j++) {
+        System.out.println("i: " + i + ", j: " + j);
+    }
+}
+```
+
+<Callout type="warning" title="Nested Loop Performance">
+  Be careful with nested loops! They can slow down your mod significantly.
+
+  ```java
+  // This runs 1,000,000 times!
+  for (int i = 0; i < 1000; i++) {
+      for (int j = 0; j < 1000; j++) {
+          // Code here
+      }
+  }
+  ```
+
+  Try to avoid deeply nested loops when processing large amounts of data.
+</Callout>
diff --git a/content/docs/sq-AL/guides/java-basics/05-arrays.mdx b/content/docs/sq-AL/guides/java-basics/05-arrays.mdx
new file mode 100644
index 00000000..b00d18fb
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/05-arrays.mdx
@@ -0,0 +1,306 @@
+---
+title: 05 - Arrays
+description: Learn how to store and manage collections of data using arrays.
+---
+
+Arrays let you store multiple values of the same type in a single variable. Think of an array as a row of boxes, each holding one item.
+
+## Creating Arrays
+
+### Method 1: Declare and Initialize Separately
+
+```java
+int[] numbers;           // Declare
+numbers = new int[5];    // Create array with 5 spaces
+```
+
+### Method 2: All at Once
+
+```java
+int[] numbers = new int[5];
+```
+
+### Method 3: With Initial Values
+
+```java
+int[] numbers = {10, 20, 30, 40, 50};
+```
+
+<Callout type="info" title="Array Size">
+  Once you create an array, its size is **fixed**. You can't add or remove elements later!
+
+  ```java
+  int[] inventory = new int[9];  // Always has exactly 9 slots
+  ```
+</Callout>
+
+## Accessing Array Elements
+
+Arrays use **index** numbers starting from **0**:
+
+```java
+String[] players = {"Alice", "Bob", "Charlie"};
+
+System.out.println(players[0]); // "Alice"
+System.out.println(players[1]); // "Bob"
+System.out.println(players[2]); // "Charlie"
+```
+
+### Visual Representation
+
+| Index | 0       | 1     | 2         |
+| ----- | ------- | ----- | --------- |
+| Value | "Alice" | "Bob" | "Charlie" |
+
+## Modifying Array Values
+
+```java
+int[] health = {100, 80, 90};
+
+health[1] = 60;  // Change Bob's health to 60
+
+System.out.println(health[0]); // 100
+System.out.println(health[1]); // 60
+System.out.println(health[2]); // 90
+```
+
+## Array Length
+
+Use `.length` to get the size of an array:
+
+```java
+int[] scores = {45, 67, 89, 92, 55};
+System.out.println(scores.length); // 5
+```
+
+<Callout type="warning" title="Length is Not a Method">
+  Notice there are no parentheses! It's `array.length`, not `array.length()`.
+</Callout>
+
+## Looping Through Arrays
+
+### Using For Loop
+
+```java
+String[] items = {"Sword", "Shield", "Potion"};
+
+for (int i = 0; i < items.length; i++) {
+    System.out.println(items[i]);
+}
+```
+
+### Using Enhanced For Loop (For-Each)
+
+```java
+String[] items = {"Sword", "Shield", "Potion"};
+
+for (String item : items) {
+    System.out.println(item);
+}
+```
+
+<Callout type="info" title="Enhanced For Loop">
+  The enhanced for loop is simpler and safer, but you can't modify the array or know the current index.
+
+  ```java
+  // When you need the index
+  for (int i = 0; i < items.length; i++) {
+      System.out.println(i + ": " + items[i]);
+  }
+
+  // When you just need the values
+  for (String item : items) {
+      System.out.println(item);
+  }
+  ```
+</Callout>
+
+## Multidimensional Arrays
+
+Arrays can hold other arrays, creating a grid:
+
+```java
+int[][] grid = {
+    {1, 2, 3},
+    {4, 5, 6},
+    {7, 8, 9}
+};
+
+System.out.println(grid[0][0]); // 1
+System.out.println(grid[1][2]); // 6
+System.out.println(grid[2][1]); // 8
+```
+
+### Visual Representation
+
+|       | 0 | 1 | 2 |
+| ----- | - | - | - |
+| **0** | 1 | 2 | 3 |
+| **1** | 4 | 5 | 6 |
+| **2** | 7 | 8 | 9 |
+
+### Looping Through 2D Arrays
+
+```java tab="Code"
+int[][] grid = {
+    {1, 2, 3},
+    {4, 5, 6}
+};
+
+for (int row = 0; row < grid.length; row++) {
+    for (int col = 0; col < grid[row].length; col++) {
+        System.out.print(grid[row][col] + " ");
+    }
+    System.out.println();
+}
+```
+
+```java tab="Output"
+1 2 3
+4 5 6
+```
+
+## Practical Examples
+
+### Player Inventory System
+
+```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");
+    }
+}
+```
+
+### Find Highest Score
+
+```java
+int[] scores = {45, 92, 67, 88, 55, 71};
+int highest = scores[0];
+
+for (int i = 1; i < scores.length; i++) {
+    if (scores[i] > highest) {
+        highest = scores[i];
+    }
+}
+
+System.out.println("Highest score: " + highest);
+```
+
+### Calculate Average
+
+```java
+double[] temperatures = {23.5, 25.0, 22.8, 24.3, 26.1};
+double sum = 0;
+
+for (double temp : temperatures) {
+    sum += temp;
+}
+
+double average = sum / temperatures.length;
+System.out.println("Average temperature: " + average);
+```
+
+### Block Grid (2D Array)
+
+```java
+String[][] terrain = new String[5][5];
+
+// Fill with grass
+for (int x = 0; x < 5; x++) {
+    for (int z = 0; z < 5; z++) {
+        terrain[x][z] = "grass";
+    }
+}
+
+// Place some stone
+terrain[2][2] = "stone";
+terrain[1][3] = "stone";
+
+// Display grid
+for (int x = 0; x < terrain.length; x++) {
+    for (int z = 0; z < terrain[x].length; z++) {
+        System.out.print(terrain[x][z] + " ");
+    }
+    System.out.println();
+}
+```
+
+## Common Array Operations
+
+### Copy an Array
+
+```java
+int[] original = {1, 2, 3, 4, 5};
+int[] copy = original.clone();
+
+// Or manually
+int[] copy2 = new int[original.length];
+for (int i = 0; i < original.length; i++) {
+    copy2[i] = original[i];
+}
+```
+
+### Search for a Value
+
+```java
+String[] items = {"Sword", "Shield", "Potion", "Bow"};
+String target = "Potion";
+int foundIndex = -1;
+
+for (int i = 0; i < items.length; i++) {
+    if (items[i].equals(target)) {
+        foundIndex = i;
+        break;
+    }
+}
+
+if (foundIndex != -1) {
+    System.out.println("Found at index: " + foundIndex);
+} else {
+    System.out.println("Not found");
+}
+```
+
+### Count Occurrences
+
+```java
+String[] blocks = {"stone", "dirt", "stone", "grass", "stone"};
+String searchFor = "stone";
+int count = 0;
+
+for (String block : blocks) {
+    if (block.equals(searchFor)) {
+        count++;
+    }
+}
+
+System.out.println(searchFor + " appears " + count + " times");
+```
+
+## Array Limitations
+
+<Callout type="warning" title="Fixed Size">
+  Arrays can't grow or shrink. If you need flexibility, you'll learn about `ArrayList` later!
+
+  ```java
+  int[] numbers = new int[5];
+  // Can't add a 6th element!
+
+  // If you need more space, create a new array
+  int[] bigger = new int[10];
+  for (int i = 0; i < numbers.length; i++) {
+      bigger[i] = numbers[i];
+  }
+  ```
+</Callout>
diff --git a/content/docs/sq-AL/guides/java-basics/06-methods-functions.mdx b/content/docs/sq-AL/guides/java-basics/06-methods-functions.mdx
new file mode 100644
index 00000000..e8e60761
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/06-methods-functions.mdx
@@ -0,0 +1,432 @@
+---
+title: 06 - Methods (Functions)
+description: Learn how to organize and reuse code with methods.
+---
+
+Methods are reusable blocks of code that perform specific tasks. They help you avoid repeating code and make your programs easier to understand.
+
+## What is a Method?
+
+Think of a method as a recipe. You define it once, then use it whenever you need it.
+
+```java tab="Code"
+public class Game {
+    public static void main(String[] args) {
+        greet();        // Call the method
+        greet();        // Call it again!
+    }
+    
+    // Method definition
+    public static void greet() {
+        System.out.println("Welcome to Hytale!");
+    }
+}
+```
+
+```text tab="Output"
+Welcome to Hytale!
+Welcome to Hytale!
+```
+
+## Method Structure
+
+```java
+public static void methodName() {
+//  ^      ^     ^      ^       ^
+//  |      |     |      |       |
+// access static return name  parameters
+// modifier       type
+    // Code goes here
+}
+```
+
+We'll learn what `public` and `static` mean later. For now, just use them.
+
+## Methods with Parameters
+
+Parameters let you pass data into methods:
+
+```java
+public static void greetPlayer(String name) {
+    System.out.println("Hello, " + name + "!");
+}
+
+public static void main(String[] args) {
+    greetPlayer("Alice");  // Hello, Alice!
+    greetPlayer("Bob");    // Hello, Bob!
+}
+```
+
+### Multiple Parameters
+
+```java
+public static void dealDamage(String target, int damage) {
+    System.out.println(target + " takes " + damage + " damage!");
+}
+
+public static void main(String[] args) {
+    dealDamage("Zombie", 20);    // Zombie takes 20 damage!
+    dealDamage("Skeleton", 15);  // Skeleton takes 15 damage!
+}
+```
+
+<Callout type="info" title="Parameter Order Matters">
+  When calling a method, arguments must match the parameter order:
+
+  ```java
+  public static void createItem(String name, int quantity, double price) {
+      // ...
+  }
+
+  // Correct
+  createItem("Sword", 1, 50.0);
+
+  // Wrong - Order matters!
+  createItem(1, "Sword", 50.0);  // Error!
+  ```
+</Callout>
+
+## Methods with Return Values
+
+Methods can send data back using `return`:
+
+```java
+public static int add(int a, int b) {
+    int sum = a + b;
+    return sum;
+}
+
+public static void main(String[] args) {
+    int result = add(5, 3);
+    System.out.println(result);  // 8
+}
+```
+
+The return type must match what you return:
+
+* `void` - Returns nothing
+* `int` - Returns an integer
+* `double` - Returns a decimal
+* `boolean` - Returns true/false
+* `String` - Returns text
+
+```java
+public static String getItemName() {
+    return "Diamond Sword";
+}
+
+public static boolean isPlayerAlive(int health) {
+    return health > 0;
+}
+
+public static double calculateDamage(int attack, double multiplier) {
+    return attack * multiplier;
+}
+```
+
+<Callout type="warning" title="Return Stops Execution">
+  Once a method hits `return`, it immediately exits. Code after `return` won't run!
+
+  ```java
+  public static int getValue() {
+      return 10;
+      System.out.println("This never runs!");  // Unreachable code!
+  }
+  ```
+</Callout>
+
+## Practical Examples
+
+### Health System
+
+```java tab="Code"
+public static void displayHealth(String name, int health, int maxHealth) {
+    double percentage = (health * 100.0) / maxHealth;
+    System.out.println(name + ": " + health + "/" + maxHealth + 
+                      " (" + percentage + "%)");
+}
+
+public static void main(String[] args) {
+    displayHealth("Player", 75, 100);
+    displayHealth("Boss", 450, 500);
+}
+```
+
+```text tab="Output"
+Player: 75/100 (75.0%)
+Boss: 450/500 (90.0%)
+```
+
+### Damage Calculator
+
+```java tab="Code"
+public static int calculateDamage(int baseAttack, int weaponDamage, boolean isCritical) {
+    int totalDamage = baseAttack + weaponDamage;
+    
+    if (isCritical) {
+        totalDamage *= 2;
+    }
+    
+    return totalDamage;
+}
+
+public static void main(String[] args) {
+    int damage1 = calculateDamage(10, 15, false);  // 25
+    int damage2 = calculateDamage(10, 15, true);   // 50
+    
+    System.out.println("Normal hit: " + damage1);
+    System.out.println("Critical hit: " + damage2);
+}
+```
+
+### Level Requirements
+
+```java tab="Code"
+public static int getXPForLevel(int level) {
+    return level * 100;
+}
+
+public static boolean canLevelUp(int currentXP, int currentLevel) {
+    int required = getXPForLevel(currentLevel + 1);
+    return currentXP >= required;
+}
+
+public static void main(String[] args) {
+    int playerXP = 450;
+    int playerLevel = 4;
+    
+    if (canLevelUp(playerXP, playerLevel)) {
+        System.out.println("You can level up!");
+    } else {
+        int needed = getXPForLevel(playerLevel + 1) - playerXP;
+        System.out.println("Need " + needed + " more XP");
+    }
+}
+```
+
+### Distance Calculator
+
+```java tab="Code"
+public static double calculateDistance(int x1, int y1, int x2, int y2) {
+    int dx = x2 - x1;
+    int dy = y2 - y1;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+public static boolean isInRange(int x1, int y1, int x2, int y2, double range) {
+    double distance = calculateDistance(x1, y1, x2, y2);
+    return distance <= range;
+}
+
+public static void main(String[] args) {
+    // Check if enemy is in attack range
+    if (isInRange(0, 0, 5, 5, 10.0)) {
+        System.out.println("Target in range!");
+    }
+}
+```
+
+## Method Overloading
+
+You can have multiple methods with the same name but different parameters:
+
+```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
+}
+```
+
+<Callout type="info" title="Method Overloading Rules">
+  Methods are considered different if they have:
+
+  * Different number of parameters
+  * Different types of parameters
+  * Different order of parameters
+
+  ```java
+  public static void test(int a) { }
+  public static void test(int a, int b) { }        // Different count
+  public static void test(double a) { }            // Different type
+  public static void test(String a, int b) { }     // Different types
+  public static void test(int a, String b) { }     // Different order
+
+  // Wrong - Only return type is different
+  public static int test(int a) { }
+  ```
+</Callout>
+
+## Common Patterns in Hytale Modding
+
+### Item Creation
+
+```java
+public static Item createItem(String name, int durability) {
+    Item item = new Item();
+    item.setName(name);
+    item.setDurability(durability);
+    return item;
+}
+
+public static Item createSword() {
+    return createItem("Sword", 100);
+}
+
+public static Item createPickaxe() {
+    return createItem("Pickaxe", 150);
+}
+```
+
+### Block Placement Validation
+
+```java
+public static boolean canPlaceBlock(int x, int y, int z) {
+    // Check if position is valid
+    if (y < 0 || y > 255) {
+        return false;
+    }
+    
+    // Check if block already exists
+    if (isBlockAt(x, y, z)) {
+        return false;
+    }
+    
+    return true;
+}
+
+public static void placeBlock(int x, int y, int z, String type) {
+    if (canPlaceBlock(x, y, z)) {
+        // Place the block
+        System.out.println("Placed " + type + " at (" + x + ", " + y + ", " + z + ")");
+    } else {
+        System.out.println("Cannot place block there!");
+    }
+}
+```
+
+### Player State Checks
+
+```java
+public static boolean isLowHealth(int health, int maxHealth) {
+    return (health * 100.0 / maxHealth) < 25;
+}
+
+public static String getHealthStatus(int health, int maxHealth) {
+    double percentage = (health * 100.0) / maxHealth;
+    
+    if (percentage >= 75) {
+        return "Healthy";
+    } else if (percentage >= 50) {
+        return "Injured";
+    } else if (percentage >= 25) {
+        return "Critical";
+    } else {
+        return "Near Death";
+    }
+}
+```
+
+## Best Practices
+
+<Callout type="info" title="Method Naming">
+  Use descriptive verb-based names that explain what the method does:
+
+  ```java
+  // Good
+  public static void calculateDamage() { }
+  public static boolean isPlayerAlive() { }
+  public static String getItemName() { }
+  public static void displayInventory() { }
+
+  // Bad
+  public static void dmg() { }        // Too short
+  public static void method1() { }    // Not descriptive
+  public static void stuff() { }      // Too vague
+  ```
+</Callout>
+
+## Practice Exercises
+
+1. **Temperature Converter**: Write methods to convert:
+   * Celsius to Fahrenheit: `(C × 9/5) + 32`
+   * Fahrenheit to Celsius: `(F - 32) × 5/9`
+
+2. **Circle Calculator**: Create methods that calculate:
+   * Area: `π × radius²`
+   * Circumference: `2 × π × radius`
+   * Use `Math.PI` for π
+
+3. **Item Durability**: Write these methods:
+   * `damageItem(int current, int damage)` - returns new durability
+   * `isBroken(int durability)` - returns true if durability is less than or equal to 0
+   * `repairItem(int current, int max)` - returns max durability
+
+4. **Password Validator**: Create a method that checks if a password is valid:
+   * At least 8 characters long
+   * Contains at least one number
+   * Returns true if valid, false otherwise
+
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
+## Common Mistakes
+
+```java
+// Wrong - Forgetting return statement
+public static int getValue() {
+    int x = 10;
+    // Forgot to return!
+} !
+
+// Correct
+public static int getValue() {
+    int x = 10;
+    return x;
+}
+
+// Wrong - Wrong return type
+public static int getText() {
+    return "Hello";  // Error! Should return int, not String
+}
+
+// Correct
+public static String getText() {
+    return "Hello";
+}
+
+// Wrong - Not calling the method
+public static void main(String[] args) {
+    greet;  // Error! Missing ()
+}
+
+// Correct
+public static void main(String[] args) {
+    greet();
+}
+```
+
+---
diff --git a/content/docs/sq-AL/guides/java-basics/07-introduction-oop.mdx b/content/docs/sq-AL/guides/java-basics/07-introduction-oop.mdx
new file mode 100644
index 00000000..058b7e5e
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/07-introduction-oop.mdx
@@ -0,0 +1,378 @@
+---
+title: 07 - Introduction to Object-Oriented Programming
+description: Learn the fundamentals of classes and objects in Java.
+---
+
+Object-Oriented Programming (OOP) is the foundation of Java and Hytale modding. Instead of just having variables and methods floating around, we organize them into **classes** and **objects**.
+
+## What is a Class?
+
+A class is a blueprint for creating objects. Think of it like a recipe or a template.
+
+```java
+public class Player {
+    // Properties (data)
+    String name;
+    int health;
+    int level;
+    
+    // Behavior (methods)
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+    }
+}
+```
+
+## What is an Object?
+
+An object is an instance created from a class. If a class is a blueprint, an object is the actual thing built from that blueprint.
+
+```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!
+    }
+}
+```
+
+<Callout type="info" title="Class vs Object">
+  **Class** = Blueprint (the idea of a player)
+  **Object** = Actual thing (Alice, Bob, specific players)
+
+  One class can create many objects, just like one recipe can make many cakes!
+</Callout>
+
+## Creating a Simple Class
+
+Let's create a `Sword` class for Hytale:
+
+```java
+public class Sword {
+    // Properties
+    String name;
+    int damage;
+    int durability;
+    
+    // Method to use the sword
+    public void attack(String target) {
+        System.out.println("Attacking " + target + " for " + damage + " damage!");
+        durability -= 1;
+        
+        if (durability <= 0) {
+            System.out.println(name + " broke!");
+        }
+    }
+    
+    // Method to display info
+    public void displayInfo() {
+        System.out.println("Weapon: " + name);
+        System.out.println("Damage: " + damage);
+        System.out.println("Durability: " + durability);
+    }
+}
+```
+
+Using the class:
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Sword sword = new Sword();
+        sword.name = "Iron Sword";
+        sword.damage = 15;
+        sword.durability = 3;
+        
+        sword.displayInfo();
+        sword.attack("Zombie");
+        sword.attack("Skeleton");
+        sword.attack("Spider");  // This will break the sword
+    }
+}
+```
+
+## Constructors
+
+Instead of setting properties one by one, use a **constructor** to initialize objects:
+
+```java
+public class Sword {
+    String name;
+    int damage;
+    int durability;
+    
+    // Constructor
+    public Sword(String weaponName, int weaponDamage, int weaponDurability) {
+        name = weaponName;
+        damage = weaponDamage;
+        durability = weaponDurability;
+    }
+    
+    public void attack(String target) {
+        System.out.println("Attacking " + target + " for " + damage + " damage!");
+        durability--;
+    }
+}
+```
+
+Now creating swords is easier:
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        // Much cleaner!
+        Sword ironSword = new Sword("Iron Sword", 15, 100);
+        Sword diamondSword = new Sword("Diamond Sword", 25, 200);
+        
+        ironSword.attack("Zombie");
+        diamondSword.attack("Boss");
+    }
+}
+```
+
+<Callout type="info" title="Constructor Rules">
+  * Same name as the class
+  * No return type (not even `void`)
+  * Called automatically when you use `new`
+  * Can have multiple constructors (overloading)
+
+  ```java
+  public class Item {
+      String name;
+      int value;
+      
+      // Constructor with all parameters
+      public Item(String name, int value) {
+          this.name = name;
+          this.value = value;
+      }
+      
+      // Constructor with just name
+      public Item(String name) {
+          this.name = name;
+          this.value = 0;  // Default value
+      }
+  }
+  ```
+</Callout>
+
+## The `this` Keyword
+
+`this` refers to the current object. Use it to clarify when parameter names match property names:
+
+```java
+public class Player {
+    String name;
+    int health;
+    
+    public Player(String name, int health) {
+        this.name = name;      // this.name = the property
+        this.health = health;  // name = the parameter
+    }
+}
+```
+
+Without `this`, Java gets confused:
+
+```java
+public Player(String name, int health) {
+    name = name;      // ❌ Which name? Ambiguous!
+    health = health;  // ❌ Which health? Ambiguous!
+}
+```
+
+## Practical Examples
+
+### Item Class
+
+```java
+public class Item {
+    String name;
+    String type;
+    int quantity;
+    double weight;
+    
+    public Item(String name, String type, int quantity, double weight) {
+        this.name = name;
+        this.type = type;
+        this.quantity = quantity;
+        this.weight = weight;
+    }
+    
+    public void use() {
+        if (quantity > 0) {
+            quantity--;
+            System.out.println("Used " + name + ". Remaining: " + quantity);
+        } else {
+            System.out.println("No more " + name + " left!");
+        }
+    }
+    
+    public double getTotalWeight() {
+        return weight * quantity;
+    }
+}
+```
+
+```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
+    }
+}
+```
+
+### Monster Class
+
+```java
+public class Monster {
+    String name;
+    int health;
+    int attack;
+    boolean isHostile;
+    
+    public Monster(String name, int health, int attack, boolean isHostile) {
+        this.name = name;
+        this.health = health;
+        this.attack = attack;
+        this.isHostile = isHostile;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+        
+        if (health <= 0) {
+            System.out.println(name + " was defeated!");
+        } else {
+            System.out.println(name + " has " + health + " health left.");
+        }
+    }
+    
+    public int attackPlayer() {
+        if (isHostile && health > 0) {
+            System.out.println(name + " attacks for " + attack + " damage!");
+            return attack;
+        }
+        return 0;
+    }
+    
+    public boolean isAlive() {
+        return health > 0;
+    }
+}
+```
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Monster zombie = new Monster("Zombie", 50, 10, true);
+        Monster chicken = new Monster("Chicken", 10, 0, false);
+        
+        zombie.takeDamage(20);        // Zombie took 20 damage!
+        int damage = zombie.attackPlayer();  // Zombie attacks for 10 damage!
+        
+        if (zombie.isAlive()) {
+            System.out.println("Monster is still alive!");
+        }
+    }
+}
+```
+
+### Block Class
+
+```java
+public class Block {
+    String type;
+    int x, y, z;
+    boolean isSolid;
+    int hardness;
+    
+    public Block(String type, int x, int y, int z, boolean isSolid, int hardness) {
+        this.type = type;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.isSolid = isSolid;
+        this.hardness = hardness;
+    }
+    
+    public void breakBlock() {
+        System.out.println("Breaking " + type + " block at (" + x + ", " + y + ", " + z + ")");
+        System.out.println("Hardness: " + hardness);
+    }
+    
+    public String getPosition() {
+        return "(" + x + ", " + y + ", " + z + ")";
+    }
+    
+    public boolean canWalkThrough() {
+        return !isSolid;
+    }
+}
+```
+
+## Access Modifiers (Preview)
+
+You've seen `public` - it means "anyone can access this". We'll learn more about access control later, but here's a preview:
+
+```java
+public class Example {
+    public String publicVar;      // Anyone can access
+    private String privateVar;    // Only this class can access
+    /* (no modifier) */ String defaultVar; // Package access
+}
+```
+
+For now, use `public` for everything. We'll learn when to use `private` in the next article.
+
+<Callout type="info" title="Why Use Classes?">
+  Classes help you:
+
+  * **Organize** related data and methods together
+  * **Reuse** code easily (create many objects from one class)
+  * **Model** real-world things (players, items, monsters)
+  * **Maintain** code (changes in one place affect all objects)
+
+  Without classes, managing 100 players would require 100 separate variables for each property. With classes, it's just 100 Player objects!
+</Callout>
+
+## Practice Exercises
+
+1. **Create a `Potion` Class**:
+   * Properties: name, healAmount, uses
+   * Constructor to set all properties
+   * Method `drink()` that heals and decreases uses
+   * Method `isEmpty()` that returns true if uses less than or equal to 0
+
+2. **Create a `Chest` Class**:
+   * Properties: isLocked, itemCount, capacity
+   * Constructor
+   * Method `addItem()` that checks capacity
+   * Method `unlock()` that sets isLocked to false
+   * Method `isFull()` that checks if itemCount >= capacity
+
+3. **Create a `Villager` Class**:
+   * Properties: name, profession, tradeCount
+   * Constructor
+   * Method `greet()` that prints a greeting
+   * Method `trade()` that increases tradeCount
+   * Method `getInfo()` that displays all properties
+
+4. **Create Multiple Objects**: Using any class you made, create 3 different objects and test all their methods.
diff --git a/content/docs/sq-AL/guides/java-basics/08-access-modifiers.mdx b/content/docs/sq-AL/guides/java-basics/08-access-modifiers.mdx
new file mode 100644
index 00000000..af560932
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/08-access-modifiers.mdx
@@ -0,0 +1,595 @@
+---
+title: 08 - Encapsulation and Access Modifiers
+description: Learn how to protect and control access to your class data.
+---
+
+Encapsulation is about hiding the internal details of a class and controlling how its data is accessed and modified. This prevents bugs and makes your code more maintainable.
+
+## The Problem Without Encapsulation
+
+```java
+public class Player {
+    public String name;
+    public int health;
+    public int maxHealth;
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Player player = new Player();
+        player.health = 100;
+        player.maxHealth = 100;
+        
+        // Oops! Someone can break the rules
+        player.health = 500;      // Health over maximum!
+        player.health = -50;      // Negative health!
+        player.name = "";         // Empty name!
+    }
+}
+```
+
+Without protection, anyone can set invalid values!
+
+## Access Modifiers
+
+Java has keywords that control who can access your class members:
+
+| Modifier    | Class | Package | Subclass | World |
+| ----------- | ----- | ------- | -------- | ----- |
+| `public`    | ✓     | ✓       | ✓        | ✓     |
+| `protected` | ✓     | ✓       | ✓        | ✗     |
+| (none)      | ✓     | ✓       | ✗        | ✗     |
+| `private`   | ✓     | ✗       | ✗        | ✗     |
+
+**For now, focus on:**
+
+* `public` - Anyone can access
+* `private` - Only this class can access
+
+## Making Properties Private
+
+```java
+public class Player {
+    private String name;
+    private int health;
+    private int maxHealth;
+    
+    public Player(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+}
+```
+
+Now you can't access properties directly:
+
+```java
+Player player = new Player("Alice", 100);
+player.health = 500;  // ❌ Error! health is private
+```
+
+## Getters and Setters
+
+To access private properties, create **getter** and **setter** methods:
+
+```java
+public class Player {
+    private String name;
+    private int health;
+    private int maxHealth;
+    
+    public Player(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+    
+    // Getter - returns the value
+    public int getHealth() {
+        return health;
+    }
+    
+    // Setter - sets the value with validation
+    public void setHealth(int health) {
+        if (health < 0) {
+            this.health = 0;
+        } else if (health > maxHealth) {
+            this.health = maxHealth;
+        } else {
+            this.health = health;
+        }
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public int getMaxHealth() {
+        return maxHealth;
+    }
+}
+```
+
+Now you can safely interact with the object:
+
+```java
+Player player = new Player("Alice", 100);
+
+player.setHealth(150);  // Automatically capped at 100
+System.out.println(player.getHealth());  // 100
+
+player.setHealth(-20);  // Automatically set to 0
+System.out.println(player.getHealth());  // 0
+```
+
+<Callout type="info" title="Getter and Setter Naming">
+  Follow Java naming conventions:
+
+  * **Getter**: `get` + property name (capitalized)
+  * **Setter**: `set` + property name (capitalized)
+  * **Boolean**: `is` + property name (capitalized)
+
+  ```java
+  private int health;
+  public int getHealth() { }
+  public void setHealth(int health) { }
+
+  private boolean alive;
+  public boolean isAlive() { }
+  public void setAlive(boolean alive) { }
+
+  private String name;
+  public String getName() { }
+  public void setName(String name) { }
+  ```
+</Callout>
+
+## Benefits of Encapsulation
+
+### 1. Validation
+
+```java
+public class Item {
+    private int durability;
+    private int maxDurability;
+    
+    public void setDurability(int durability) {
+        if (durability < 0) {
+            this.durability = 0;
+        } else if (durability > maxDurability) {
+            this.durability = maxDurability;
+        } else {
+            this.durability = durability;
+        }
+    }
+    
+    public boolean isBroken() {
+        return durability <= 0;
+    }
+}
+```
+
+### 2. Read-Only Properties
+
+Sometimes you don't want a setter:
+
+```java
+public class Monster {
+    private String id;  // Should never change
+    private int health;
+    
+    public Monster(String id, int health) {
+        this.id = id;
+        this.health = health;
+    }
+    
+    // Getter only - no setter!
+    public String getId() {
+        return id;
+    }
+    
+    public int getHealth() {
+        return health;
+    }
+    
+    public void setHealth(int health) {
+        this.health = health;
+    }
+}
+```
+
+### 3. Computed Properties
+
+Getters don't have to return a field directly:
+
+```java
+public class Player {
+    private int health;
+    private int maxHealth;
+    
+    public int getHealth() {
+        return health;
+    }
+    
+    // Computed property
+    public double getHealthPercentage() {
+        return (health * 100.0) / maxHealth;
+    }
+    
+    // Computed property
+    public boolean isLowHealth() {
+        return getHealthPercentage() < 25;
+    }
+}
+```
+
+## Practical Examples
+
+### Item with Durability
+
+```java
+public class Tool {
+    private String name;
+    private int durability;
+    private int maxDurability;
+    private boolean broken;
+    
+    public Tool(String name, int maxDurability) {
+        this.name = name;
+        this.durability = maxDurability;
+        this.maxDurability = maxDurability;
+        this.broken = false;
+    }
+    
+    public void use() {
+        if (broken) {
+            System.out.println(name + " is broken!");
+            return;
+        }
+        
+        durability--;
+        System.out.println(name + " used. Durability: " + durability);
+        
+        if (durability <= 0) {
+            broken = true;
+            System.out.println(name + " broke!");
+        }
+    }
+    
+    public void repair() {
+        durability = maxDurability;
+        broken = false;
+        System.out.println(name + " repaired!");
+    }
+    
+    // Getters
+    public String getName() {
+        return name;
+    }
+    
+    public int getDurability() {
+        return durability;
+    }
+    
+    public boolean isBroken() {
+        return broken;
+    }
+    
+    public double getDurabilityPercentage() {
+        return (durability * 100.0) / maxDurability;
+    }
+}
+```
+
+### Bank Account Example
+
+```java
+public class PlayerWallet {
+    private int gold;
+    private int silver;
+    
+    public PlayerWallet() {
+        this.gold = 0;
+        this.silver = 0;
+    }
+    
+    public void addGold(int amount) {
+        if (amount > 0) {
+            gold += amount;
+            System.out.println("Added " + amount + " gold");
+        }
+    }
+    
+    public boolean spendGold(int amount) {
+        if (amount > gold) {
+            System.out.println("Not enough gold!");
+            return false;
+        }
+        
+        gold -= amount;
+        System.out.println("Spent " + amount + " gold");
+        return true;
+    }
+    
+    public int getGold() {
+        return gold;
+    }
+    
+    public int getTotalValue() {
+        // 1 gold = 100 silver
+        return gold * 100 + silver;
+    }
+}
+```
+
+### Protected Block System
+
+```java
+public class ProtectedBlock {
+    private int x, y, z;
+    private String type;
+    private String owner;
+    private boolean locked;
+    
+    public ProtectedBlock(int x, int y, int z, String type, String owner) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.type = type;
+        this.owner = owner;
+        this.locked = true;
+    }
+    
+    public boolean canBreak(String playerName) {
+        if (!locked) {
+            return true;
+        }
+        
+        return playerName.equals(owner);
+    }
+    
+    public void unlock(String playerName) {
+        if (playerName.equals(owner)) {
+            locked = false;
+            System.out.println("Block unlocked");
+        } else {
+            System.out.println("You don't own this block!");
+        }
+    }
+    
+    // Getters only - position and owner shouldn't change
+    public int getX() {
+        return x;
+    }
+    
+    public int getY() {
+        return y;
+    }
+    
+    public int getZ() {
+        return z;
+    }
+    
+    public String getOwner() {
+        return owner;
+    }
+    
+    public boolean isLocked() {
+        return locked;
+    }
+}
+```
+
+## When to Use Private vs Public
+
+<Callout type="info" title="General Rules">
+  **Make it private by default!** Only make things public if they need to be accessed from outside.
+
+  **Private:**
+
+  * Internal data (health, position, inventory)
+  * Helper methods used only within the class
+  * Anything that needs validation
+
+  **Public:**
+
+  * Methods that define the class's behavior
+  * Constructor
+  * Methods other classes need to call
+
+  ```java
+  public class Example {
+      // Private - internal data
+      private int internalCounter;
+      private String secretKey;
+      
+      // Public - part of the interface
+      public void doSomething() {
+          // Uses private helper method
+          validateData();
+      }
+      
+      // Private - internal helper
+      private void validateData() {
+          // ...
+      }
+  }
+  ```
+</Callout>
+
+## The `final` Keyword
+
+`final` means a variable can't be changed after it's set:
+
+```java
+public class Player {
+    private final String id;  // Can't change after creation
+    private String name;      // Can change
+    private int health;       // Can change
+    
+    public Player(String id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+    
+    public String getId() {
+        return id;
+    }
+    
+    // No setId() - it's final!
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+```
+
+## The `static` Keyword
+
+### Static Members
+
+A class can define two kinds of members:
+
+* **Instance members** — owned by each object (each instance has its own copy).
+
+* **Static members** — owned by the class (one shared copy for the entire type).
+
+Put simply: instance members belong to objects; static members belong to the class itself and are shared by all objects of that type.
+
+#### Declaration
+
+```java
+    /* (access modifier) */ static ... memberName; 
+```
+
+#### Example
+
+```java
+class Data {
+    public int x; // Instanced member
+    public static int y = 1000; // Static member
+
+    // Instanced member:
+    // can access to both static and non-static members
+    public void foo() {
+        x = 100; // OK - same as this.x = 100;
+        y = 100; // OK - same as Data.y = 200;
+    }
+
+    // Static member:
+    // cannot access to non-static variables
+    public static void bar() {
+        x = 100; // Error: non-static variable x cannot be renference from a static context
+        y = 100; // OK
+    }
+}
+```
+
+#### Accessing static members
+
+```java
+Data data = new Data();
+data.x = 1000; // OK
+
+data.y = 1000; // OK-ish - not really suggested; it's better to use Data.y
+Data.y = 1000; // OK - best practice
+
+Data.x = 1000; // Error: cannot access instanced variables in a static context
+```
+
+### Static Fields
+
+A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+
+It is declared as following:
+
+```java
+/* (access modifier) (optional) */ static /* final/volatile (optional) */ fieldName;
+```
+
+Let's take the same Data class example and add this constructor:
+
+```java
+public Data() {
+    y++; // remember that's the same as Data.y++;
+}
+```
+
+```java
+// Every instance of Data will have a private copy of the instanced member x
+// However it will point to the same location in memory for the member y
+Data d1 = new Data(); // y = 1001
+d1.x = 5;
+Data d2 = new Data(); // y = 1002
+d2.x = 25;
+Data d3 = new Data(); // y = 1003
+// ... and so on
+```
+
+### Static Methods
+
+Static methods essentially represent a function member of a certain class type
+
+From the Data class remember the function (instanced method) `foo` and (static method) `bar`
+
+One can access those methods via:
+
+```java
+Data d1 = new Data();
+
+d1.foo(); // Instanced method: Accessible ONLY by an object
+
+Data.bar(); // Static method: accessible without an object
+```
+
+### Static Initializer
+
+Use a *static initializer* block to run initialization logic when the class is first loaded:
+
+```java
+class OtherData {
+    private static int a = 12;
+    private static int b;
+    private static String msg;
+
+    static {
+        msg = "Initialization..."
+        System.out.println(msg);
+        b = 4;
+        // ... complex initialization that can't be done in a single expression
+    }
+}
+```
+
+## Practice Exercises
+
+1. **Create a `BankAccount` Class**:
+   * Private properties: accountNumber, balance
+   * Constructor to set account number
+   * Methods: deposit(), withdraw(), getBalance()
+   * Validation: can't withdraw more than balance
+   * Account number should be read-only
+
+2. **Create a `Door` Class**:
+   * Private properties: isLocked, keyCode
+   * Constructor to set the key code
+   * Methods: lock(), unlock(String code), isLocked()
+   * unlock() only works with correct code
+   * Code should be private (don't expose it!)
+
+3. **Create a `PlayerStats` Class**:
+   * Private properties: strength, defense, speed
+   * Constructor to set all stats
+   * Getters for all stats
+   * Method: getPowerLevel() that returns strength + defense + speed
+   * Stats can't be negative or over 100
+
+4. **Refactor a Class**: Take one of your classes from the previous lesson and add proper encapsulation:
+   * Make all properties private
+   * Add appropriate getters and setters
+   * Add validation where needed
diff --git a/content/docs/sq-AL/guides/java-basics/09-string.mdx b/content/docs/sq-AL/guides/java-basics/09-string.mdx
new file mode 100644
index 00000000..a374811b
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/09-string.mdx
@@ -0,0 +1,493 @@
+---
+title: 09 - Working with Strings
+description: Master text manipulation and string operations in Java.
+---
+
+Strings are one of the most commonly used types in Java. They're essential for handling player names, chat messages, item descriptions, and like everything you see.
+
+## String Basics
+
+Strings are objects that store text:
+
+```java
+String name = "Simon";
+String message = "Welcome to Hytale!";
+String empty = "";
+```
+
+<Callout type="warning" title="Strings are Immutable">
+  Once created, a String **cannot be changed**. Methods that seem to modify a string actually create a new one!
+
+  ```java
+  String text = "Hello";
+  text.toUpperCase();           // Creates "HELLO" but doesn't save it
+  System.out.println(text);     // Still "Hello"
+
+  String upper = text.toUpperCase();  // ✓ Save the result
+  System.out.println(upper);          // "HELLO"
+  ```
+</Callout>
+
+## String Methods
+
+### Length
+
+```java
+String name = "Alice";
+int length = name.length();
+System.out.println(length);  // 5
+```
+
+### Changing Case
+
+```java
+String text = "Hello World";
+String upper = text.toUpperCase();  // "HELLO WORLD"
+String lower = text.toLowerCase();  // "hello world"
+```
+
+### Checking Contents
+
+```java
+String message = "Welcome to Hytale";
+
+boolean hasHytale = message.contains("Hytale");  // true
+boolean hasMinecraft = message.contains("Minecraft");  // false
+
+boolean starts = message.startsWith("Welcome");  // true
+boolean ends = message.endsWith("Hytale");  // true
+```
+
+### Extracting Parts
+
+```java
+String text = "Hello World";
+
+char first = text.charAt(0);      // 'H'
+char last = text.charAt(10);      // 'd'
+
+String sub1 = text.substring(0, 5);   // "Hello"
+String sub2 = text.substring(6);      // "World"
+```
+
+<Callout type="info" title="Substring Indices">
+  `substring(start, end)` includes `start` but excludes `end`:
+
+  ```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)
+  ```
+</Callout>
+
+### Replacing Text
+
+```java
+String text = "I love Minecraft";
+String replaced = text.replace("Minecraft", "Hytale");
+System.out.println(replaced);  // "I love Hytale"
+
+String noSpaces = "Hello World".replace(" ", "");
+System.out.println(noSpaces);  // "HelloWorld"
+```
+
+### Trimming Whitespace
+
+```java
+String messy = "  Hello World  ";
+String clean = messy.trim();
+System.out.println(clean);  // "Hello World" (no spaces at ends)
+```
+
+### Splitting Strings
+
+```java
+String command = "give player sword 5";
+String[] parts = command.split(" ");
+
+System.out.println(parts[0]);  // "give"
+System.out.println(parts[1]);  // "player"
+System.out.println(parts[2]);  // "sword"
+System.out.println(parts[3]);  // "5"
+```
+
+## String Comparison
+
+<Callout type="warning" title="Never Use == for Strings">
+  Always use `.equals()` to compare string contents!
+
+  ```java
+  String name1 = "Steve";
+  String name2 = "Steve";
+
+  // Wrong - Compares object references
+  if (name1 == name2) {
+      System.out.println("Same");
+  }
+
+  // Correct - Compares actual text
+  if (name1.equals(name2)) {
+      System.out.println("Same");
+  }
+
+  // Ignore case when comparing
+  if (name1.equalsIgnoreCase("steve")) {
+      System.out.println("Same (ignoring case)");
+  }
+  ```
+</Callout>
+
+### Comparing Order
+
+```java
+String a = "Apple";
+String b = "Banana";
+
+int result = a.compareTo(b);
+// result < 0 if a comes before b
+// result == 0 if a equals b
+// result > 0 if a comes after b
+
+if (a.compareTo(b) < 0) {
+    System.out.println(a + " comes before " + b);
+}
+```
+
+## String Concatenation
+
+### Using + Operator
+
+```java
+String first = "Hello";
+String second = "World";
+String combined = first + " " + second;  // "Hello World"
+
+int score = 100;
+String message = "Score: " + score;  // "Score: 100"
+```
+
+### Using concat()
+
+```java
+String result = "Hello".concat(" World");  // "Hello World"
+```
+
+### Building Long Strings
+
+For many concatenations, use `StringBuilder`:
+
+```java
+StringBuilder builder = new StringBuilder();
+builder.append("Player: ");
+builder.append("Alice");
+builder.append(", Level: ");
+builder.append(10);
+builder.append(", Health: ");
+builder.append(100);
+
+String result = builder.toString();
+System.out.println(result);
+// "Player: Alice, Level: 10, Health: 100"
+```
+
+<Callout type="info" title="Why StringBuilder?">
+  Regular concatenation creates many temporary strings:
+
+  ```java
+  // Inefficient - Creates many temporary strings
+  String result = "";
+  for (int i = 0; i < 1000; i++) {
+      result = result + i;  // Creates 1000 temporary strings!
+  }
+
+  // Efficient - StringBuilder is mutable
+  StringBuilder sb = new StringBuilder();
+  for (int i = 0; i < 1000; i++) {
+      sb.append(i);  // Modifies one object
+  }
+  String result = sb.toString();
+  ```
+
+  Use `StringBuilder` when building strings in loops!
+</Callout>
+
+## Practical Examples
+
+### Parse Player Command
+
+```java
+public class CommandParser {
+    public static void parseCommand(String command) {
+        // "/give Steve diamond_sword 1"
+        String[] parts = command.split(" ");
+        
+        String action = parts[0].replace("/", "");  // "give"
+        String player = parts[1];                   // "Steve"
+        String item = parts[2];                     // "diamond_sword"
+        int amount = Integer.parseInt(parts[3]);    // 1
+        
+        System.out.println("Action: " + action);
+        System.out.println("Player: " + player);
+        System.out.println("Item: " + item);
+        System.out.println("Amount: " + amount);
+    }
+    
+    public static void main(String[] args) {
+        parseCommand("/give Steve diamond_sword 1");
+    }
+}
+```
+
+### Format Player Display Name
+
+```java
+public class PlayerFormatter {
+    public static String formatName(String name, int level, String rank) {
+        StringBuilder formatted = new StringBuilder();
+        
+        if (rank != null && !rank.isEmpty()) {
+            formatted.append("[").append(rank).append("] ");
+        }
+        
+        formatted.append(name);
+        formatted.append(" (Lv. ").append(level).append(")");
+        
+        return formatted.toString();
+    }
+    
+    public static void main(String[] args) {
+        String display1 = formatName("Alice", 10, "VIP");
+        System.out.println(display1);  // "[VIP] Alice (Lv. 10)"
+        
+        String display2 = formatName("Bob", 5, null);
+        System.out.println(display2);  // "Bob (Lv. 5)"
+    }
+}
+```
+
+### Validate Username
+
+```java
+public class UsernameValidator {
+    public static boolean isValid(String username) {
+        // Rules: 3-16 characters, letters and numbers only
+        
+        if (username == null || username.isEmpty()) {
+            return false;
+        }
+        
+        username = username.trim();
+        
+        if (username.length() < 3 || username.length() > 16) {
+            return false;
+        }
+        
+        for (int i = 0; i < username.length(); i++) {
+            char c = username.charAt(i);
+            if (!Character.isLetterOrDigit(c)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+    
+    public static void main(String[] args) {
+        System.out.println(isValid("Steve"));      // true
+        System.out.println(isValid("Player_123")); // false (has underscore)
+        System.out.println(isValid("ab"));         // false (too short)
+        System.out.println(isValid(""));           // false (empty)
+    }
+}
+```
+
+### Item Description Builder
+
+```java
+public class ItemDescription {
+    public static String buildDescription(String name, String rarity, 
+                                         int damage, int durability) {
+        StringBuilder desc = new StringBuilder();
+        
+        // Title with rarity color code
+        desc.append(getRarityColor(rarity));
+        desc.append(name);
+        desc.append("\n");
+        
+        // Stats
+        desc.append("Damage: ").append(damage).append("\n");
+        desc.append("Durability: ").append(durability).append("/");
+        desc.append(durability).append("\n");
+        desc.append("Rarity: ").append(rarity);
+        
+        return desc.toString();
+    }
+    
+    private static String getRarityColor(String rarity) {
+        switch (rarity.toLowerCase()) {
+            case "legendary": return "§6";  // Gold
+            case "epic": return "§5";       // Purple
+            case "rare": return "§9";       // Blue
+            case "common": return "§f";     // White
+            default: return "§7";           // Gray
+        }
+    }
+    
+    public static void main(String[] args) {
+        String desc = buildDescription("Excalibur", "Legendary", 50, 1000);
+        System.out.println(desc);
+    }
+}
+```
+
+### Chat Message Filter
+
+```java
+public class ChatFilter {
+    private static String[] bannedWords = {"badword1", "badword2"};
+    
+    public static String filterMessage(String message) {
+        String filtered = message.toLowerCase();
+        
+        for (String word : bannedWords) {
+            if (filtered.contains(word)) {
+                String replacement = "*".repeat(word.length());
+                filtered = filtered.replace(word, replacement);
+            }
+        }
+        
+        return filtered;
+    }
+    
+    public static void main(String[] args) {
+        String message = "This is a badword1 test";
+        String clean = filterMessage(message);
+        System.out.println(clean);  // "this is a ******** test"
+    }
+}
+```
+
+## String Formatting
+
+### Using String.format()
+
+```java
+String name = "Alice";
+int level = 10;
+double health = 85.5;
+
+String formatted = String.format("%s is level %d with %.1f%% health", 
+                                 name, level, health);
+System.out.println(formatted);
+// "Alice is level 10 with 85.5% health"
+```
+
+<Callout type="info" title="Format Specifiers">
+  Common format codes:
+
+  - `%s` - String
+  - `%d` - Integer
+  - `%f` - Floating point
+  - `%.2f` - Float with 2 decimal places
+  - `%n` - New line (platform independent)
+
+  ```java
+  String.format("Name: %s", "Steve");          // "Name: Steve"
+  String.format("Level: %d", 10);              // "Level: 10"
+  String.format("Health: %.1f", 85.5);         // "Health: 85.5"
+  String.format("Position: (%d, %d, %d)", 
+                10, 64, -5);                    // "Position: (10, 64, -5)"
+  ```
+</Callout>
+
+## Common String Operations
+
+### Check if String is Empty
+
+```java
+String text = "";
+
+// Check for empty or null
+if (text == null || text.isEmpty()) {
+    System.out.println("Empty!");
+}
+
+// Check for empty, null, or whitespace only
+if (text == null || text.trim().isEmpty()) {
+    System.out.println("Empty or whitespace!");
+}
+```
+
+### Count Occurrences
+
+```java
+public static int countOccurrences(String text, String target) {
+    int count = 0;
+    int index = 0;
+    
+    while ((index = text.indexOf(target, index)) != -1) {
+        count++;
+        index += target.length();
+    }
+    
+    return count;
+}
+
+// Usage
+int count = countOccurrences("hello hello world", "hello");
+System.out.println(count);  // 2
+```
+
+### Reverse a String
+
+```java
+public static String reverse(String text) {
+    StringBuilder sb = new StringBuilder(text);
+    return sb.reverse().toString();
+}
+
+// Usage
+String reversed = reverse("Hello");
+System.out.println(reversed);  // "olleH"
+```
+
+### Check if Palindrome
+
+```java
+public static boolean isPalindrome(String text) {
+    String cleaned = text.toLowerCase().replaceAll("[^a-z0-9]", "");
+    String reversed = new StringBuilder(cleaned).reverse().toString();
+    return cleaned.equals(reversed);
+}
+
+// Usage
+System.out.println(isPalindrome("racecar"));     // true
+System.out.println(isPalindrome("hello"));       // false
+```
+
+## Practice Exercises
+
+1. **Username Checker**: Write a method that checks if a username:
+   - Is between 3 and 16 characters
+   - Contains only letters, numbers, and underscores
+   - Doesn't start with a number
+   - Returns true if valid, false otherwise
+
+2. **Command Parser**: Parse this command format: `/teleport x y z`
+   - Extract the coordinates
+   - Convert them to integers
+   - Return an array of the three values
+
+3. **Chat Formatter**: Create a method that formats chat messages:
+   - Input: player name, rank, message
+   - Output: `"[RANK] PlayerName: message"`
+   - If no rank, just show `"PlayerName: message"`
+
+4. **Word Counter**: Count how many words are in a sentence (words are separated by spaces)
+
+5. **Title Case**: Convert a string to title case:
+   - Input: `"hello world"`
+   - Output: `"Hello World"`
diff --git a/content/docs/sq-AL/guides/java-basics/10-arraylist.mdx b/content/docs/sq-AL/guides/java-basics/10-arraylist.mdx
new file mode 100644
index 00000000..343ae5d5
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/10-arraylist.mdx
@@ -0,0 +1,530 @@
+---
+title: 10 - ArrayList and Collections
+description: Learn to use flexible, resizable collections in Java.
+---
+
+Arrays have a fixed size, but what if you need to add or remove elements? That's where `ArrayList` comes in - a resizable collection that grows and shrinks automatically.
+
+## ArrayList Basics
+
+```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]
+    }
+}
+```
+
+<Callout type="info" title="ArrayList vs Array">
+  | **Array**                               | **ArrayList**                                         |
+  | --------------------------------------- | ----------------------------------------------------- |
+  | Fixed size                              | Resizable (grows/shrinks)                             |
+  | Can hold primitives (int, double, etc.) | Can only hold objects (Integer, Double, String, etc.) |
+  | Faster access                           | More features (add, remove, etc.)                     |
+  | `int[] numbers = new int[10];`          | `ArrayList<Integer> numbers = new ArrayList<>();`     |
+</Callout>
+
+## Creating ArrayLists
+
+```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<>();
+```
+
+<Callout type="warning" title="Primitives in ArrayList">
+  You can't use primitives directly. Use their wrapper classes:
+
+  ```java
+  // Wrong
+  ArrayList<int> numbers = new ArrayList<>();
+
+  // Correct - Use wrapper class
+  ArrayList<Integer> numbers = new ArrayList<>();
+  ```
+
+  Wrapper classes:
+
+  - `int` → `Integer`
+  - `double` → `Double`
+  - `boolean` → `Boolean`
+  - `char` → `Character`
+</Callout>
+
+## Common ArrayList Methods
+
+### Adding Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+
+items.add("Sword");           // Add to end
+items.add("Shield");
+items.add(0, "Helmet");       // Add at specific index
+
+System.out.println(items);    // [Helmet, Sword, Shield]
+```
+
+### Accessing Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+String first = items.get(0);    // "Sword"
+String second = items.get(1);   // "Shield"
+
+int size = items.size();        // 2
+```
+
+### Removing Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+items.add("Potion");
+
+items.remove(1);               // Remove by index (Shield)
+items.remove("Potion");        // Remove by value
+
+System.out.println(items);     // [Sword]
+```
+
+### Checking Contents
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+boolean hasSword = items.contains("Sword");     // true
+boolean hasAxe = items.contains("Axe");         // false
+
+boolean isEmpty = items.isEmpty();              // false
+int size = items.size();                        // 2
+```
+
+### Modifying Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Wooden Sword");
+
+items.set(0, "Iron Sword");    // Replace at index 0
+
+System.out.println(items);     // [Iron Sword]
+```
+
+### Clearing All Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+items.clear();                 // Remove everything
+System.out.println(items);     // []
+```
+
+## Looping Through ArrayList
+
+### Using For Loop
+
+```java
+ArrayList<String> players = new ArrayList<>();
+players.add("Alice");
+players.add("Bob");
+players.add("Charlie");
+
+for (int i = 0; i < players.size(); i++) {
+    System.out.println(players.get(i));
+}
+```
+
+### Using Enhanced For Loop
+
+```java
+for (String player : players) {
+    System.out.println(player);
+}
+```
+
+### Using forEach (Java 8+)
+
+```java
+players.forEach(player -> System.out.println(player));
+```
+
+## Practical Examples
+
+### Player Inventory System
+
+```java
+import java.util.ArrayList;
+
+public class Inventory {
+    private ArrayList<String> items;
+    private int maxSize;
+    
+    public Inventory(int maxSize) {
+        this.items = new ArrayList<>();
+        this.maxSize = maxSize;
+    }
+    
+    public boolean addItem(String item) {
+        if (items.size() >= maxSize) {
+            System.out.println("Inventory full!");
+            return false;
+        }
+        
+        items.add(item);
+        System.out.println("Added: " + item);
+        return true;
+    }
+    
+    public boolean removeItem(String item) {
+        if (items.remove(item)) {
+            System.out.println("Removed: " + item);
+            return true;
+        }
+        
+        System.out.println("Item not found!");
+        return false;
+    }
+    
+    public void displayInventory() {
+        System.out.println("=== Inventory (" + items.size() + "/" + maxSize + ") ===");
+        for (int i = 0; i < items.size(); i++) {
+            System.out.println((i + 1) + ". " + items.get(i));
+        }
+    }
+    
+    public int getItemCount() {
+        return items.size();
+    }
+    
+    public boolean isFull() {
+        return items.size() >= maxSize;
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        Inventory inv = new Inventory(5);
+        
+        inv.addItem("Sword");
+        inv.addItem("Shield");
+        inv.addItem("Potion");
+        inv.displayInventory();
+        
+        inv.removeItem("Shield");
+        inv.displayInventory();
+    }
+}
+```
+
+### Quest System
+
+```java
+import java.util.ArrayList;
+
+public class QuestManager {
+    private ArrayList<String> activeQuests;
+    private ArrayList<String> completedQuests;
+    
+    public QuestManager() {
+        this.activeQuests = new ArrayList<>();
+        this.completedQuests = new ArrayList<>();
+    }
+    
+    public void startQuest(String questName) {
+        if (!activeQuests.contains(questName)) {
+            activeQuests.add(questName);
+            System.out.println("Quest started: " + questName);
+        } else {
+            System.out.println("Quest already active!");
+        }
+    }
+    
+    public void completeQuest(String questName) {
+        if (activeQuests.remove(questName)) {
+            completedQuests.add(questName);
+            System.out.println("Quest completed: " + questName);
+        } else {
+            System.out.println("Quest not found in active quests!");
+        }
+    }
+    
+    public void displayQuests() {
+        System.out.println("\n=== Active Quests ===");
+        if (activeQuests.isEmpty()) {
+            System.out.println("No active quests");
+        } else {
+            for (String quest : activeQuests) {
+                System.out.println("- " + quest);
+            }
+        }
+        
+        System.out.println("\n=== Completed Quests ===");
+        if (completedQuests.isEmpty()) {
+            System.out.println("No completed quests");
+        } else {
+            for (String quest : completedQuests) {
+                System.out.println("" + quest);
+            }
+        }
+    }
+    
+    public int getTotalCompleted() {
+        return completedQuests.size();
+    }
+}
+```
+
+### Leaderboard System
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class Leaderboard {
+    private ArrayList<Integer> scores;
+    private ArrayList<String> players;
+    
+    public Leaderboard() {
+        this.scores = new ArrayList<>();
+        this.players = new ArrayList<>();
+    }
+    
+    public void addScore(String player, int score) {
+        players.add(player);
+        scores.add(score);
+        System.out.println(player + " scored " + score + " points!");
+    }
+    
+    public void displayTop(int count) {
+        System.out.println("\n=== Top " + count + " Players ===");
+        
+        // Create copies to sort
+        ArrayList<Integer> sortedScores = new ArrayList<>(scores);
+        ArrayList<String> sortedPlayers = new ArrayList<>(players);
+        
+        // Bubble sort (simple for learning)
+        for (int i = 0; i < sortedScores.size() - 1; i++) {
+            for (int j = 0; j < sortedScores.size() - i - 1; j++) {
+                if (sortedScores.get(j) < sortedScores.get(j + 1)) {
+                    // Swap scores
+                    int tempScore = sortedScores.get(j);
+                    sortedScores.set(j, sortedScores.get(j + 1));
+                    sortedScores.set(j + 1, tempScore);
+                    
+                    // Swap players
+                    String tempPlayer = sortedPlayers.get(j);
+                    sortedPlayers.set(j, sortedPlayers.get(j + 1));
+                    sortedPlayers.set(j + 1, tempPlayer);
+                }
+            }
+        }
+        
+        // Display top scores
+        int limit = Math.min(count, sortedScores.size());
+        for (int i = 0; i < limit; i++) {
+            System.out.println((i + 1) + ". " + sortedPlayers.get(i) + 
+                             " - " + sortedScores.get(i) + " points");
+        }
+    }
+}
+```
+
+### Online Players Tracker
+
+```java
+import java.util.ArrayList;
+
+public class OnlinePlayersTracker {
+    private ArrayList<String> onlinePlayers;
+    
+    public OnlinePlayersTracker() {
+        this.onlinePlayers = new ArrayList<>();
+    }
+    
+    public void playerJoin(String playerName) {
+        if (!onlinePlayers.contains(playerName)) {
+            onlinePlayers.add(playerName);
+            broadcast(playerName + " joined the game");
+            updatePlayerCount();
+        }
+    }
+    
+    public void playerLeave(String playerName) {
+        if (onlinePlayers.remove(playerName)) {
+            broadcast(playerName + " left the game");
+            updatePlayerCount();
+        }
+    }
+    
+    public boolean isOnline(String playerName) {
+        return onlinePlayers.contains(playerName);
+    }
+    
+    public int getPlayerCount() {
+        return onlinePlayers.size();
+    }
+    
+    public void listPlayers() {
+        System.out.println("\n=== Online Players (" + getPlayerCount() + ") ===");
+        for (String player : onlinePlayers) {
+            System.out.println("• " + player);
+        }
+    }
+    
+    private void broadcast(String message) {
+        System.out.println("[Server] " + message);
+    }
+    
+    private void updatePlayerCount() {
+        System.out.println("Players online: " + getPlayerCount());
+    }
+}
+```
+
+## ArrayList of Custom Objects
+
+You can store your own classes in ArrayLists:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    
+    public Player(String name, int level) {
+        this.name = name;
+        this.level = level;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public int getLevel() {
+        return level;
+    }
+    
+    @Override
+    public String toString() {
+        return name + " (Lv. " + level + ")";
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        ArrayList<Player> players = new ArrayList<>();
+        
+        players.add(new Player("Alice", 10));
+        players.add(new Player("Bob", 15));
+        players.add(new Player("Charlie", 8));
+        
+        // Display all players
+        for (Player player : players) {
+            System.out.println(player);
+        }
+        
+        // Find player by name
+        for (Player player : players) {
+            if (player.getName().equals("Bob")) {
+                System.out.println("Found: " + player);
+            }
+        }
+    }
+}
+```
+
+## Useful ArrayList Operations
+
+### Convert to Array
+
+```java
+ArrayList<String> list = new ArrayList<>();
+list.add("A");
+list.add("B");
+
+String[] array = list.toArray(new String[0]);
+```
+
+### Convert Array to ArrayList
+
+```java
+String[] array = {"A", "B", "C"};
+ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
+```
+
+### Copy an ArrayList
+
+```java
+ArrayList<String> original = new ArrayList<>();
+original.add("A");
+original.add("B");
+
+// Shallow copy
+ArrayList<String> copy = new ArrayList<>(original);
+```
+
+### Find Index of Element
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+int index = items.indexOf("Shield");  // 1
+int notFound = items.indexOf("Axe");  // -1
+```
+
+## Practice Exercises
+
+1. **Shopping Cart**: Create a shopping cart system:
+   - Add items
+   - Remove items
+   - Calculate total items
+   - Clear cart
+
+2. **Friend List**: Create a friend management system:
+   - Add friend
+   - Remove friend
+   - Check if someone is a friend
+   - Display all friends
+
+3. **Todo List**: Build a todo list:
+   - Add task
+   - Mark task as complete (move to completed list)
+   - Display active tasks
+   - Display completed tasks
+
+4. **High Scores**: Create a high score system:
+   - Add scores
+   - Display top 5 scores in order
+   - Remove lowest score if more than 10 scores exist
+
+---
diff --git a/content/docs/sq-AL/guides/java-basics/11-hashmaps.mdx b/content/docs/sq-AL/guides/java-basics/11-hashmaps.mdx
new file mode 100644
index 00000000..a06511cf
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/11-hashmaps.mdx
@@ -0,0 +1,568 @@
+---
+title: 11 - HashMap and Key-Value Storage
+description: Learn to store and retrieve data using key-value pairs.
+---
+
+A `HashMap` stores data in key-value pairs, like a real-world dictionary. You look up a word (key) to find its definition (value). This is perfect for player data, item properties, and configuration settings.
+
+## HashMap Basics
+
+```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);
+    }
+}
+```
+
+<Callout type="info" title="HashMap vs ArrayList">
+  | **HashMap**                     | **ArrayList**                 |
+  | ------------------------------- | ----------------------------- |
+  | Unordered                       | Ordered by index (0, 1, 2...) |
+  | Access by key (can be any type) | Access by position            |
+  | Good for looking up values      | Good for lists of items       |
+  | Each key is unique              | Can have duplicates           |
+
+  ```java
+  // ArrayList - access by number
+  ArrayList<String> players = new ArrayList<>();
+  players.add("Alice");
+  String player = players.get(0);  // Get first player
+
+  // HashMap - access by name
+  HashMap<String, Integer> levels = new HashMap<>();
+  levels.put("Alice", 10);
+  int level = levels.get("Alice");  // Get Alice's level
+  ```
+</Callout>
+
+## Common HashMap Methods
+
+### Adding and Updating
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+
+scores.put("Alice", 100);     // Add new entry
+scores.put("Bob", 150);
+scores.put("Alice", 200);     // Update existing (Alice now 200)
+```
+
+### Getting Values
+
+```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)
+```
+
+### Checking for Keys/Values
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+boolean hasAlice = scores.containsKey("Alice");    // true
+boolean hasDave = scores.containsKey("Dave");      // false
+
+boolean has100 = scores.containsValue(100);        // true
+boolean has200 = scores.containsValue(200);        // false
+```
+
+### Removing Entries
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+scores.put("Bob", 150);
+
+scores.remove("Alice");           // Remove by key
+System.out.println(scores);       // {Bob=150}
+
+scores.clear();                   // Remove everything
+System.out.println(scores);       // {}
+```
+
+### Size and Empty Check
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+int size = scores.size();         // 1
+boolean empty = scores.isEmpty(); // false
+```
+
+## Looping Through HashMap
+
+### Loop Through Keys
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+scores.put("Bob", 150);
+scores.put("Charlie", 75);
+
+for (String name : scores.keySet()) {
+    System.out.println(name);
+}
+// Output: Alice, Bob, Charlie (order may vary)
+```
+
+### Loop Through Values
+
+```java
+for (Integer score : scores.values()) {
+    System.out.println(score);
+}
+// Output: 100, 150, 75 (order may vary)
+```
+
+### Loop Through Both Keys and Values
+
+```java
+for (String name : scores.keySet()) {
+    int score = scores.get(name);
+    System.out.println(name + ": " + score);
+}
+
+// Or using entrySet (more efficient)
+for (var entry : scores.entrySet()) {
+    String name = entry.getKey();
+    int score = entry.getValue();
+    System.out.println(name + ": " + score);
+}
+```
+
+<Callout type="info" title="HashMap Order">
+  HashMap does **not** maintain insertion order! If you need order, use `LinkedHashMap`:
+
+  ```java
+  import java.util.LinkedHashMap;
+
+  LinkedHashMap<String, Integer> orderedScores = new LinkedHashMap<>();
+  orderedScores.put("Alice", 100);
+  orderedScores.put("Bob", 150);
+  orderedScores.put("Charlie", 75);
+
+  // Will print in insertion order
+  for (String name : orderedScores.keySet()) {
+      System.out.println(name);
+  }
+  // Output: Alice, Bob, Charlie (guaranteed order)
+  ```
+</Callout>
+
+## Practical Examples
+
+### Player Statistics System
+
+```java
+import java.util.HashMap;
+
+public class PlayerStats {
+    private HashMap<String, Integer> stats;
+    
+    public PlayerStats() {
+        this.stats = new HashMap<>();
+        // Initialize default stats
+        stats.put("health", 100);
+        stats.put("mana", 50);
+        stats.put("strength", 10);
+        stats.put("defense", 5);
+        stats.put("speed", 8);
+    }
+    
+    public int getStat(String statName) {
+        return stats.getOrDefault(statName, 0);
+    }
+    
+    public void setStat(String statName, int value) {
+        stats.put(statName, value);
+    }
+    
+    public void modifyStat(String statName, int amount) {
+        int current = getStat(statName);
+        stats.put(statName, current + amount);
+    }
+    
+    public void displayStats() {
+        System.out.println("=== Player Stats ===");
+        for (var entry : stats.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        PlayerStats stats = new PlayerStats();
+        stats.displayStats();
+        
+        stats.modifyStat("strength", 5);
+        stats.modifyStat("health", -20);
+        
+        System.out.println("\nAfter modifications:");
+        stats.displayStats();
+    }
+}
+```
+
+### Item Properties Database
+
+```java
+import java.util.HashMap;
+
+public class ItemDatabase {
+    private HashMap<String, HashMap<String, Object>> items;
+    
+    public ItemDatabase() {
+        this.items = new HashMap<>();
+    }
+    
+    public void addItem(String itemName) {
+        HashMap<String, Object> properties = new HashMap<>();
+        properties.put("damage", 0);
+        properties.put("durability", 100);
+        properties.put("rarity", "Common");
+        properties.put("stackable", true);
+        
+        items.put(itemName, properties);
+    }
+    
+    public void setProperty(String itemName, String property, Object value) {
+        if (items.containsKey(itemName)) {
+            items.get(itemName).put(property, value);
+        }
+    }
+    
+    public Object getProperty(String itemName, String property) {
+        if (items.containsKey(itemName)) {
+            return items.get(itemName).get(property);
+        }
+        return null;
+    }
+    
+    public void displayItem(String itemName) {
+        if (!items.containsKey(itemName)) {
+            System.out.println("Item not found!");
+            return;
+        }
+        
+        System.out.println("=== " + itemName + " ===");
+        HashMap<String, Object> props = items.get(itemName);
+        for (var entry : props.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        ItemDatabase db = new ItemDatabase();
+        
+        db.addItem("Iron Sword");
+        db.setProperty("Iron Sword", "damage", 15);
+        db.setProperty("Iron Sword", "rarity", "Uncommon");
+        
+        db.displayItem("Iron Sword");
+    }
+}
+```
+
+### Configuration Manager
+
+```java
+import java.util.HashMap;
+
+public class GameConfig {
+    private HashMap<String, String> settings;
+    
+    public GameConfig() {
+        this.settings = new HashMap<>();
+        loadDefaults();
+    }
+    
+    private void loadDefaults() {
+        settings.put("difficulty", "normal");
+        settings.put("musicVolume", "50");
+        settings.put("sfxVolume", "50");
+        settings.put("renderDistance", "10");
+        settings.put("showFPS", "false");
+    }
+    
+    public String getSetting(String key) {
+        return settings.getOrDefault(key, "");
+    }
+    
+    public void setSetting(String key, String value) {
+        settings.put(key, value);
+        System.out.println("Set " + key + " to " + value);
+    }
+    
+    public int getIntSetting(String key) {
+        String value = getSetting(key);
+        try {
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            return 0;
+        }
+    }
+    
+    public boolean getBooleanSetting(String key) {
+        return "true".equalsIgnoreCase(getSetting(key));
+    }
+    
+    public void displaySettings() {
+        System.out.println("=== Game Settings ===");
+        for (var entry : settings.entrySet()) {
+            System.out.println(entry.getKey() + " = " + entry.getValue());
+        }
+    }
+}
+```
+
+### Player Inventory with Quantities
+
+```java
+import java.util.HashMap;
+
+public class Inventory {
+    private HashMap<String, Integer> items;
+    private int maxSlots;
+    
+    public Inventory(int maxSlots) {
+        this.items = new HashMap<>();
+        this.maxSlots = maxSlots;
+    }
+    
+    public boolean addItem(String itemName, int quantity) {
+        if (items.size() >= maxSlots && !items.containsKey(itemName)) {
+            System.out.println("Inventory full!");
+            return false;
+        }
+        
+        int current = items.getOrDefault(itemName, 0);
+        items.put(itemName, current + quantity);
+        System.out.println("Added " + quantity + "x " + itemName);
+        return true;
+    }
+    
+    public boolean removeItem(String itemName, int quantity) {
+        if (!items.containsKey(itemName)) {
+            System.out.println("Don't have that item!");
+            return false;
+        }
+        
+        int current = items.get(itemName);
+        if (current < quantity) {
+            System.out.println("Not enough " + itemName);
+            return false;
+        }
+        
+        if (current == quantity) {
+            items.remove(itemName);
+        } else {
+            items.put(itemName, current - quantity);
+        }
+        
+        System.out.println("Removed " + quantity + "x " + itemName);
+        return true;
+    }
+    
+    public int getQuantity(String itemName) {
+        return items.getOrDefault(itemName, 0);
+    }
+    
+    public boolean hasItem(String itemName) {
+        return items.containsKey(itemName);
+    }
+    
+    public void displayInventory() {
+        System.out.println("\n=== Inventory (" + items.size() + "/" + maxSlots + " slots) ===");
+        if (items.isEmpty()) {
+            System.out.println("Empty");
+        } else {
+            for (var entry : items.entrySet()) {
+                System.out.println(entry.getKey() + " x" + entry.getValue());
+            }
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        Inventory inv = new Inventory(10);
+        
+        inv.addItem("Wood", 64);
+        inv.addItem("Stone", 32);
+        inv.addItem("Wood", 20);  // Adds to existing
+        
+        inv.displayInventory();
+        
+        inv.removeItem("Wood", 50);
+        inv.displayInventory();
+    }
+}
+```
+
+### Cooldown Manager
+
+```java
+import java.util.HashMap;
+
+public class CooldownManager {
+    private HashMap<String, Long> cooldowns;
+    
+    public CooldownManager() {
+        this.cooldowns = new HashMap<>();
+    }
+    
+    public void startCooldown(String ability, long durationMs) {
+        long endTime = System.currentTimeMillis() + durationMs;
+        cooldowns.put(ability, endTime);
+        System.out.println(ability + " on cooldown for " + (durationMs / 1000) + " seconds");
+    }
+    
+    public boolean isOnCooldown(String ability) {
+        if (!cooldowns.containsKey(ability)) {
+            return false;
+        }
+        
+        long endTime = cooldowns.get(ability);
+        long now = System.currentTimeMillis();
+        
+        if (now >= endTime) {
+            cooldowns.remove(ability);
+            return false;
+        }
+        
+        return true;
+    }
+    
+    public long getRemainingTime(String ability) {
+        if (!isOnCooldown(ability)) {
+            return 0;
+        }
+        
+        long endTime = cooldowns.get(ability);
+        long now = System.currentTimeMillis();
+        return (endTime - now) / 1000;  // Return seconds
+    }
+    
+    public boolean useAbility(String ability, long cooldownSeconds) {
+        if (isOnCooldown(ability)) {
+            long remaining = getRemainingTime(ability);
+            System.out.println(ability + " is on cooldown (" + remaining + "s remaining)");
+            return false;
+        }
+        
+        System.out.println("Used " + ability + "!");
+        startCooldown(ability, cooldownSeconds * 1000);
+        return true;
+    }
+}
+```
+
+## HashMap with Custom Objects
+
+Store your own classes as values:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    private int health;
+    
+    public Player(String name, int level) {
+        this.name = name;
+        this.level = level;
+        this.health = 100;
+    }
+    
+    // Getters and setters...
+    
+    @Override
+    public String toString() {
+        return name + " (Lv. " + level + ", HP: " + health + ")";
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        HashMap<String, Player> players = new HashMap<>();
+        
+        players.put("player1", new Player("Alice", 10));
+        players.put("player2", new Player("Bob", 15));
+        
+        // Get and use player
+        Player alice = players.get("player1");
+        System.out.println(alice);
+    }
+}
+```
+
+## Nested HashMaps
+
+HashMaps can contain other HashMaps:
+
+```java
+// Store multiple properties per player
+HashMap<String, HashMap<String, Integer>> playerData = new HashMap<>();
+
+// Add player with stats
+HashMap<String, Integer> aliceStats = new HashMap<>();
+aliceStats.put("level", 10);
+aliceStats.put("health", 100);
+aliceStats.put("mana", 50);
+playerData.put("Alice", aliceStats);
+
+// Access nested data
+int aliceLevel = playerData.get("Alice").get("level");
+System.out.println("Alice's level: " + aliceLevel);
+```
+
+## Practice Exercises
+
+1. **Phone Book**: Create a phone book that stores names and phone numbers. Add methods to:
+   - Add contact
+   - Find number by name
+   - Delete contact
+   - Display all contacts
+
+2. **Grade Manager**: Store student names and grades. Create methods to:
+   - Add student with grade
+   - Update grade
+   - Calculate class average
+   - Find highest grade
+
+3. **Word Counter**: Write a program that counts how many times each word appears in a sentence using a HashMap.
+
+4. **Item Shop**: Create a shop where items have names and prices. Add methods to:
+   - Add item with price
+   - Get item price
+   - Apply discount to all items
+   - Display all items and prices
+
+---
diff --git a/content/docs/sq-AL/guides/java-basics/12-exception-handling.mdx b/content/docs/sq-AL/guides/java-basics/12-exception-handling.mdx
new file mode 100644
index 00000000..a43155d0
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/12-exception-handling.mdx
@@ -0,0 +1,504 @@
+---
+title: 12 - Exception Handling
+description: Learn how to handle errors gracefully in your Java programs.
+---
+
+Exceptions are errors that occur while your program is running. Instead of crashing, you can "catch" these errors and handle them gracefully.
+
+## What is an Exception?
+
+An exception is an event that disrupts the normal flow of your program:
+
+```java
+String text = null;
+System.out.println(text.length());  // NullPointerException - crashes!
+```
+
+Without handling, this crashes your mod and breaks the game!
+
+## Try-Catch Blocks
+
+Use `try-catch` to handle exceptions:
+
+```java
+try {
+    // Code that might throw an exception
+    String text = null;
+    System.out.println(text.length());
+} catch (NullPointerException e) {
+    // Code to handle the error
+    System.out.println("Error: text was null!");
+}
+
+System.out.println("Program continues...");
+```
+
+<Callout type="info" title="How Try-Catch Works">
+  1. Code in `try` block runs normally
+  2. If an exception occurs, execution jumps to `catch` block
+  3. After `catch` block, program continues normally
+  4. If no exception occurs, `catch` block is skipped
+
+  ```java
+  try {
+      // Try to do something risky
+      int result = 10 / 0;  // Division by zero!
+  } catch (ArithmeticException e) {
+      // Handle the error
+      System.out.println("Can't divide by zero!");
+  }
+  // Program keeps running
+  ```
+</Callout>
+
+## Common Exception Types
+
+### NullPointerException
+
+Accessing methods/properties on null objects:
+
+```java
+String name = null;
+
+try {
+    int length = name.length();
+} catch (NullPointerException e) {
+    System.out.println("Name is null!");
+}
+```
+
+### ArrayIndexOutOfBoundsException
+
+Accessing invalid array index:
+
+```java
+int[] numbers = {1, 2, 3};
+
+try {
+    int value = numbers[10];  // Index 10 doesn't exist!
+} catch (ArrayIndexOutOfBoundsException e) {
+    System.out.println("Invalid array index!");
+}
+```
+
+### NumberFormatException
+
+Converting invalid strings to numbers:
+
+```java
+try {
+    int number = Integer.parseInt("abc");  // Not a number!
+} catch (NumberFormatException e) {
+    System.out.println("Invalid number format!");
+}
+```
+
+### ArithmeticException
+
+Math errors like division by zero:
+
+```java
+try {
+    int result = 10 / 0;
+} catch (ArithmeticException e) {
+    System.out.println("Math error!");
+}
+```
+
+## Multiple Catch Blocks
+
+Handle different exceptions differently:
+
+```java
+String input = "abc";
+
+try {
+    int number = Integer.parseInt(input);
+    int result = 100 / number;
+    System.out.println(result);
+} catch (NumberFormatException e) {
+    System.out.println("Invalid number!");
+} catch (ArithmeticException e) {
+    System.out.println("Cannot divide by zero!");
+}
+```
+
+## Catching Multiple Exception Types
+
+Catch multiple exceptions in one block:
+
+```java
+try {
+    // Some risky code
+} catch (NumberFormatException | ArithmeticException e) {
+    System.out.println("Math-related error occurred!");
+}
+```
+
+## The Finally Block
+
+Code that **always** runs, whether exception occurs or not:
+
+```java
+try {
+    System.out.println("Opening file...");
+    // Code that might fail
+} catch (Exception e) {
+    System.out.println("Error: " + e.getMessage());
+} finally {
+    System.out.println("Closing file...");
+    // This ALWAYS runs - good for cleanup
+}
+```
+
+<Callout type="info" title="When to Use Finally">
+  Use `finally` for cleanup tasks that must always happen:
+
+  - Closing files
+  - Releasing resources
+  - Saving data
+  - Logging
+
+  ```java
+  FileReader file = null;
+  try {
+      file = new FileReader("data.txt");
+      // Read file
+  } catch (Exception e) {
+      System.out.println("Error reading file");
+  } finally {
+      if (file != null) {
+          file.close();  // Always close the file!
+      }
+  }
+  ```
+</Callout>
+
+## Getting Exception Information
+
+The exception object contains useful information:
+
+```java
+try {
+    int result = Integer.parseInt("xyz");
+} catch (NumberFormatException e) {
+    System.out.println("Message: " + e.getMessage());
+    System.out.println("Type: " + e.getClass().getName());
+    e.printStackTrace();  // Print full error details
+}
+```
+
+## Practical Examples
+
+### Safe Player Input
+
+```java
+import java.util.Scanner;
+
+public class PlayerInput {
+    public static int getPlayerChoice(Scanner scanner) {
+        while (true) {
+            try {
+                System.out.print("Enter choice (1-5): ");
+                String input = scanner.nextLine();
+                int choice = Integer.parseInt(input);
+                
+                if (choice < 1 || choice > 5) {
+                    System.out.println("Please enter a number between 1 and 5");
+                    continue;
+                }
+                
+                return choice;
+            } catch (NumberFormatException e) {
+                System.out.println("Invalid input! Please enter a number.");
+            }
+        }
+    }
+    
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int choice = getPlayerChoice(scanner);
+        System.out.println("You chose: " + choice);
+    }
+}
+```
+
+### Safe Item Durability Update
+
+```java
+public class Item {
+    private String name;
+    private int durability;
+    private int maxDurability;
+    
+    public Item(String name, int maxDurability) {
+        this.name = name;
+        this.durability = maxDurability;
+        this.maxDurability = maxDurability;
+    }
+    
+    public void damage(int amount) {
+        try {
+            if (amount < 0) {
+                throw new IllegalArgumentException("Damage cannot be negative!");
+            }
+            
+            durability -= amount;
+            
+            if (durability < 0) {
+                durability = 0;
+            }
+            
+            System.out.println(name + " durability: " + durability + "/" + maxDurability);
+            
+            if (durability == 0) {
+                System.out.println(name + " broke!");
+            }
+        } catch (IllegalArgumentException e) {
+            System.out.println("Error: " + e.getMessage());
+        }
+    }
+}
+```
+
+### Safe Config Loading
+
+```java
+import java.util.HashMap;
+
+public class ConfigLoader {
+    private HashMap<String, String> settings;
+    
+    public ConfigLoader() {
+        this.settings = new HashMap<>();
+        loadDefaults();
+    }
+    
+    private void loadDefaults() {
+        settings.put("maxPlayers", "10");
+        settings.put("difficulty", "normal");
+        settings.put("pvpEnabled", "true");
+    }
+    
+    public int getIntSetting(String key, int defaultValue) {
+        try {
+            String value = settings.get(key);
+            if (value == null) {
+                return defaultValue;
+            }
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            System.out.println("Invalid number for " + key + ", using default");
+            return defaultValue;
+        }
+    }
+    
+    public boolean getBooleanSetting(String key, boolean defaultValue) {
+        try {
+            String value = settings.get(key);
+            if (value == null) {
+                return defaultValue;
+            }
+            return Boolean.parseBoolean(value);
+        } catch (Exception e) {
+            System.out.println("Invalid boolean for " + key + ", using default");
+            return defaultValue;
+        }
+    }
+    
+    public void setSetting(String key, String value) {
+        if (key == null || value == null) {
+            System.out.println("Key and value cannot be null!");
+            return;
+        }
+        settings.put(key, value);
+    }
+}
+```
+
+### Safe Array Access
+
+```java
+public class Inventory {
+    private String[] items;
+    
+    public Inventory(int size) {
+        this.items = new String[size];
+    }
+    
+    public boolean setItem(int slot, String item) {
+        try {
+            if (slot < 0 || slot >= items.length) {
+                throw new ArrayIndexOutOfBoundsException("Invalid slot: " + slot);
+            }
+            
+            items[slot] = item;
+            System.out.println("Placed " + item + " in slot " + slot);
+            return true;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Error: " + e.getMessage());
+            return false;
+        }
+    }
+    
+    public String getItem(int slot) {
+        try {
+            return items[slot];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Invalid slot: " + slot);
+            return null;
+        }
+    }
+}
+```
+
+### Command Parser with Error Handling
+
+```java
+public class CommandParser {
+    public static void parseCommand(String command) {
+        try {
+            if (command == null || command.trim().isEmpty()) {
+                throw new IllegalArgumentException("Command cannot be empty!");
+            }
+            
+            String[] parts = command.split(" ");
+            
+            if (parts.length < 2) {
+                throw new IllegalArgumentException("Invalid command format!");
+            }
+            
+            String action = parts[0];
+            String target = parts[1];
+            
+            switch (action) {
+                case "give":
+                    if (parts.length < 4) {
+                        throw new IllegalArgumentException("Usage: give <player> <item> <amount>");
+                    }
+                    String item = parts[2];
+                    int amount = Integer.parseInt(parts[3]);
+                    
+                    if (amount <= 0) {
+                        throw new IllegalArgumentException("Amount must be positive!");
+                    }
+                    
+                    System.out.println("Giving " + amount + " " + item + " to " + target);
+                    break;
+                    
+                case "tp":
+                    if (parts.length < 5) {
+                        throw new IllegalArgumentException("Usage: tp <player> <x> <y> <z>");
+                    }
+                    int x = Integer.parseInt(parts[2]);
+                    int y = Integer.parseInt(parts[3]);
+                    int z = Integer.parseInt(parts[4]);
+                    
+                    System.out.println("Teleporting " + target + " to " + x + ", " + y + ", " + z);
+                    break;
+                    
+                default:
+                    throw new IllegalArgumentException("Unknown command: " + action);
+            }
+        } catch (NumberFormatException e) {
+            System.out.println("Error: Invalid number in command!");
+        } catch (IllegalArgumentException e) {
+            System.out.println("Error: " + e.getMessage());
+        } catch (Exception e) {
+            System.out.println("Unexpected error: " + e.getMessage());
+        }
+    }
+    
+    public static void main(String[] args) {
+        parseCommand("give Steve diamond 5");
+        parseCommand("give Steve sword abc");  // Invalid number
+        parseCommand("tp Alice 10 64 20");
+        parseCommand("unknown command");       // Unknown command
+    }
+}
+```
+
+## Throwing Exceptions
+
+You can throw your own exceptions:
+
+```java
+public class Player {
+    private int health;
+    
+    public void setHealth(int health) {
+        if (health < 0) {
+            throw new IllegalArgumentException("Health cannot be negative!");
+        }
+        if (health > 100) {
+            throw new IllegalArgumentException("Health cannot exceed 100!");
+        }
+        this.health = health;
+    }
+}
+```
+
+<Callout type="info" title="When to Throw Exceptions">
+  Throw exceptions when:
+
+  - Method receives invalid input
+  - Operation cannot be completed
+  - Preconditions are not met
+  - Something unexpected happens
+
+  ```java
+  public void damagePlayer(int damage) {
+      if (damage < 0) {
+          throw new IllegalArgumentException("Damage must be positive!");
+      }
+      // Apply damage
+  }
+
+  public Item getItem(int slot) {
+      if (slot < 0 || slot >= inventory.length) {
+          throw new IndexOutOfBoundsException("Invalid inventory slot!");
+      }
+      return inventory[slot];
+  }
+  ```
+</Callout>
+
+## Checked vs Unchecked Exceptions
+
+<Callout type="warning" title="Exception Types">
+  **Unchecked Exceptions** (RuntimeException):
+
+  - Don't need to be caught
+  - Usually programming errors
+  - Examples: NullPointerException, ArrayIndexOutOfBoundsException
+
+  **Checked Exceptions**:
+
+  - Must be caught or declared
+  - Usually external errors (files, network)
+  - Examples: IOException, FileNotFoundException
+
+  ```java
+  // Unchecked - no need to catch
+  int result = 10 / 0;  // ArithmeticException
+
+  // Checked - must catch or declare
+  try {
+      FileReader file = new FileReader("data.txt");  // IOException
+  } catch (IOException e) {
+      // Handle error
+  }
+  ```
+</Callout>
+
+## Practice Exercises
+
+1. **Safe Division Calculator**: Create a method that divides two numbers. Handle division by zero and invalid input gracefully.
+
+2. **Player Level Setter**: Create a method that sets player level (1-100). Throw an exception if invalid, and handle it in main.
+
+3. **Safe Array Access**: Create a method that safely accesses array elements. Return null if index is invalid instead of crashing.
+
+4. **Config Parser**: Read a config string like "maxPlayers=10" and parse it. Handle invalid formats gracefully.
+
+5. **File Name Validator**: Create a method that checks if a filename is valid (no special characters, not empty). Throw exceptions for invalid names.
diff --git a/content/docs/sq-AL/guides/java-basics/13-inheritance.mdx b/content/docs/sq-AL/guides/java-basics/13-inheritance.mdx
new file mode 100644
index 00000000..1650c27a
--- /dev/null
+++ b/content/docs/sq-AL/guides/java-basics/13-inheritance.mdx
@@ -0,0 +1,629 @@
+---
+title: 13 - Inheritance
+description: Learn how to create class hierarchies and reuse code effectively.
+---
+
+Inheritance lets you create new classes based on existing ones. The new class inherits all the properties and methods of the parent class, and can add its own or modify inherited ones.
+
+## What is Inheritance?
+
+Think of inheritance like a family tree. A child inherits traits from their parent, but can also have their own unique traits.
+
+```java
+// Parent class (superclass)
+public class Entity {
+    protected String name;
+    protected int health;
+    
+    public Entity(String name, int health) {
+        this.name = name;
+        this.health = health;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+    }
+}
+
+// Child class (subclass)
+public class Player extends Entity {
+    private int level;
+    
+    public Player(String name, int health, int level) {
+        super(name, health);  // Call parent constructor
+        this.level = level;
+    }
+    
+    public void levelUp() {
+        level++;
+        System.out.println(name + " leveled up to " + level + "!");
+    }
+}
+```
+
+<Callout type="info" title="Inheritance Terminology">
+  - **Superclass/Parent**: The class being inherited from (Entity)
+  - **Subclass/Child**: The class inheriting (Player)
+  - **extends**: Keyword to inherit from a class
+  - **super**: Keyword to access parent class members
+
+  ```java
+  public class Monster extends Entity {
+      // Monster IS-A Entity
+      // Monster inherits from Entity
+      // Entity is the parent, Monster is the child
+  }
+  ```
+</Callout>
+
+## The extends Keyword
+
+Use `extends` to inherit from a class:
+
+```java
+public class Animal {
+    protected String name;
+    
+    public void makeSound() {
+        System.out.println(name + " makes a sound");
+    }
+}
+
+public class Dog extends Animal {
+    public void wagTail() {
+        System.out.println(name + " wags tail");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Dog dog = new Dog();
+        dog.name = "Buddy";
+        dog.makeSound();  // Inherited from Animal
+        dog.wagTail();    // Dog's own method
+    }
+}
+```
+
+## The super Keyword
+
+`super` refers to the parent class:
+
+### Calling Parent Constructor
+
+```java
+public class Entity {
+    protected String name;
+    
+    public Entity(String name) {
+        this.name = name;
+    }
+}
+
+public class Player extends Entity {
+    private int level;
+    
+    public Player(String name, int level) {
+        super(name);  // Call parent constructor FIRST
+        this.level = level;
+    }
+}
+```
+
+<Callout type="warning" title="Constructor Rules">
+  - `super()` must be the **first** statement in child constructor
+  - If you don't call `super()`, Java automatically calls the no-argument parent constructor
+  - If parent has no no-argument constructor, you MUST call `super()` with arguments
+
+  ```java
+  // Wrong - super() not first
+  public Player(String name, int level) {
+      this.level = level;
+      super(name);  // Error!
+  }
+
+  // Correct
+  public Player(String name, int level) {
+      super(name);  // First statement
+      this.level = level;
+  }
+  ```
+</Callout>
+
+### Calling Parent Methods
+
+```java
+public class Entity {
+    protected int health;
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println("Entity took damage!");
+    }
+}
+
+public class Player extends Entity {
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);  // Call parent version
+        if (health < 20) {
+            System.out.println("Warning: Low health!");
+        }
+    }
+}
+```
+
+## Method Overriding
+
+Child classes can replace parent methods:
+
+```java
+public class Entity {
+    public void attack() {
+        System.out.println("Entity attacks!");
+    }
+}
+
+public class Player extends Entity {
+    @Override  // Good practice to use this annotation
+    public void attack() {
+        System.out.println("Player swings sword!");
+    }
+}
+
+public class Monster extends Entity {
+    @Override
+    public void attack() {
+        System.out.println("Monster bites!");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Player player = new Player();
+        Monster monster = new Monster();
+        
+        player.attack();   // "Player swings sword!"
+        monster.attack();  // "Monster bites!"
+    }
+}
+```
+
+<Callout type="info" title="@Override Annotation">
+  Always use `@Override` when overriding methods:
+
+  - Helps catch typos (if method doesn't exist in parent, you get an error)
+  - Makes code clearer
+  - Good documentation
+
+  ```java
+  // Without @Override - typo not caught
+  public void attac() {  // Typo! Creates new method instead
+      // ...
+  }
+
+  // With @Override - error caught immediately
+  @Override
+  public void attac() {  // Error: method doesn't exist in parent
+      // ...
+  }
+  ```
+</Callout>
+
+## Access Modifiers in Inheritance
+
+- `public` - Accessible everywhere
+- `protected` - Accessible in class and subclasses
+- `private` - Only in the class (not inherited)
+
+```java
+public class Parent {
+    public int publicVar;      // Child can access
+    protected int protectedVar; // Child can access
+    private int privateVar;     // Child CANNOT access
+    
+    private void privateMethod() {
+        // Child cannot call this
+    }
+    
+    protected void protectedMethod() {
+        // Child can call this
+    }
+}
+
+public class Child extends Parent {
+    public void test() {
+        publicVar = 10;      // OK
+        protectedVar = 20;   // OK
+        privateVar = 30;     // Error!
+        
+        protectedMethod();   // OK
+        privateMethod();     // Error!
+    }
+}
+```
+
+## Practical Examples
+
+### Game Entity Hierarchy
+
+```java
+// Base class for all entities
+public class Entity {
+    protected String name;
+    protected int health;
+    protected int maxHealth;
+    protected double x, y, z;
+    
+    public Entity(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        if (health < 0) health = 0;
+        System.out.println(name + " took " + damage + " damage. Health: " + health);
+    }
+    
+    public boolean isAlive() {
+        return health > 0;
+    }
+    
+    public void moveTo(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        System.out.println(name + " moved to (" + x + ", " + y + ", " + z + ")");
+    }
+}
+
+// Player extends Entity
+public class Player extends Entity {
+    private int level;
+    private int experience;
+    private int mana;
+    
+    public Player(String name) {
+        super(name, 100);
+        this.level = 1;
+        this.experience = 0;
+        this.mana = 50;
+    }
+    
+    public void gainExperience(int amount) {
+        experience += amount;
+        System.out.println("Gained " + amount + " XP");
+        
+        if (experience >= level * 100) {
+            levelUp();
+        }
+    }
+    
+    private void levelUp() {
+        level++;
+        maxHealth += 10;
+        health = maxHealth;
+        mana += 5;
+        System.out.println("Level up! Now level " + level);
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        if (health < maxHealth * 0.25) {
+            System.out.println("⚠ WARNING: Low health!");
+        }
+    }
+}
+
+// Monster extends Entity
+public class Monster extends Entity {
+    private int attackPower;
+    private String type;
+    
+    public Monster(String name, int health, int attackPower, String type) {
+        super(name, health);
+        this.attackPower = attackPower;
+        this.type = type;
+    }
+    
+    public int attack() {
+        System.out.println(name + " attacks!");
+        return attackPower;
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        if (!isAlive()) {
+            System.out.println(name + " was defeated!");
+        }
+    }
+}
+
+// Boss extends Monster (multi-level inheritance)
+public class Boss extends Monster {
+    private int phase;
+    
+    public Boss(String name, int health, int attackPower) {
+        super(name, health, attackPower, "Boss");
+        this.phase = 1;
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        
+        // Change phase at 50% health
+        if (phase == 1 && health < maxHealth / 2) {
+            phase = 2;
+            System.out.println(name + " enters PHASE 2!");
+        }
+    }
+    
+    @Override
+    public int attack() {
+        int damage = super.attack();
+        if (phase == 2) {
+            damage *= 2;
+            System.out.println("ENRAGED ATTACK!");
+        }
+        return damage;
+    }
+}
+```
+
+### Item Hierarchy
+
+```java
+// Base Item class
+public class Item {
+    protected String name;
+    protected int value;
+    protected double weight;
+    
+    public Item(String name, int value, double weight) {
+        this.name = name;
+        this.value = value;
+        this.weight = weight;
+    }
+    
+    public void use() {
+        System.out.println("Using " + name);
+    }
+    
+    public String getInfo() {
+        return name + " ($" + value + ", " + weight + " kg)";
+    }
+}
+
+// Weapon extends Item
+public class Weapon extends Item {
+    private int damage;
+    private int durability;
+    
+    public Weapon(String name, int value, double weight, int damage, int durability) {
+        super(name, value, weight);
+        this.damage = damage;
+        this.durability = durability;
+    }
+    
+    @Override
+    public void use() {
+        if (durability > 0) {
+            System.out.println("Attacking with " + name + " for " + damage + " damage!");
+            durability--;
+        } else {
+            System.out.println(name + " is broken!");
+        }
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Damage: " + damage + ", Durability: " + durability;
+    }
+}
+
+// Consumable extends Item
+public class Consumable extends Item {
+    private int healAmount;
+    private int uses;
+    
+    public Consumable(String name, int value, double weight, int healAmount, int uses) {
+        super(name, value, weight);
+        this.healAmount = healAmount;
+        this.uses = uses;
+    }
+    
+    @Override
+    public void use() {
+        if (uses > 0) {
+            System.out.println("Used " + name + ", restored " + healAmount + " health!");
+            uses--;
+        } else {
+            System.out.println("No " + name + " left!");
+        }
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Heals: " + healAmount + ", Uses: " + uses;
+    }
+}
+
+// Armor extends Item
+public class Armor extends Item {
+    private int defense;
+    private String slot;
+    
+    public Armor(String name, int value, double weight, int defense, String slot) {
+        super(name, value, weight);
+        this.defense = defense;
+        this.slot = slot;
+    }
+    
+    @Override
+    public void use() {
+        System.out.println("Equipped " + name + " (+" + defense + " defense)");
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Defense: " + defense + ", Slot: " + slot;
+    }
+}
+```
+
+## Polymorphism
+
+Child objects can be treated as parent objects:
+
+```java
+Entity entity1 = new Player("Alice");
+Entity entity2 = new Monster("Goblin", 50, 10, "Hostile");
+Entity entity3 = new Boss("Dragon", 500, 50);
+
+// All can use Entity methods
+entity1.takeDamage(10);
+entity2.takeDamage(10);
+entity3.takeDamage(10);
+
+// Array of different types
+Entity[] entities = {
+    new Player("Bob"),
+    new Monster("Zombie", 30, 8, "Hostile"),
+    new Monster("Spider", 20, 5, "Hostile")
+};
+
+// Process all entities the same way
+for (Entity entity : entities) {
+    entity.takeDamage(5);
+}
+```
+
+<Callout type="info" title="Polymorphism Benefits">
+  Polymorphism lets you write code that works with parent types but handles child types correctly:
+
+  ```java
+  public void damageEntity(Entity entity, int damage) {
+      entity.takeDamage(damage);
+      // Works for Player, Monster, Boss, etc.
+      // Each uses their own version of takeDamage()
+  }
+
+  // Can call with any Entity type
+  damageEntity(new Player("Alice"), 10);
+  damageEntity(new Monster("Goblin", 50, 10, "Hostile"), 10);
+  damageEntity(new Boss("Dragon", 500, 50), 10);
+  ```
+</Callout>
+
+## The Object Class
+
+All classes in Java automatically inherit from `Object`:
+
+```java
+public class MyClass {
+    // Automatically extends Object
+    // Has methods like toString(), equals(), etc.
+}
+```
+
+Common Object methods to override:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    
+    @Override
+    public String toString() {
+        return "Player: " + name + " (Lv. " + level + ")";
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Player) {
+            Player other = (Player) obj;
+            return this.name.equals(other.name);
+        }
+        return false;
+    }
+}
+```
+
+## Final Classes and Methods
+
+`final` prevents inheritance or overriding:
+
+```java
+// Final class - cannot be extended
+public final class SpecialItem {
+    // No class can extend this
+}
+
+// Final method - cannot be overridden
+public class Entity {
+    public final void printName() {
+        System.out.println(name);
+    }
+}
+
+public class Player extends Entity {
+    @Override
+    public void printName() {  // Error! Method is final
+        // Cannot override
+    }
+}
+```
+
+## Common Mistakes
+
+```java
+// Wrong - Forgetting super()
+public class Player extends Entity {
+    public Player(String name) {
+        // Error! Entity has no no-arg constructor
+    }
+}
+
+// Correct
+public class Player extends Entity {
+    public Player(String name) {
+        super(name, 100);  // Call parent constructor
+    }
+}
+
+// Wrong - Accessing private members
+public class Child extends Parent {
+    public void test() {
+        privateVar = 10;  // Error! private is not inherited
+    }
+}
+
+// Correct - Use protected
+public class Parent {
+    protected int protectedVar;  // Child can access
+}
+
+// Wrong - Multiple inheritance (not allowed in Java)
+public class Child extends Parent1, Parent2 {  // Error!
+}
+
+// Correct - Single inheritance only
+public class Child extends Parent {
+}
+```
+
+## Practice Exercises
+
+1. **Vehicle Hierarchy**: Create a `Vehicle` class with properties like speed and fuel. Create `Car` and `Motorcycle` subclasses with their own unique features.
+
+2. **Shape Calculator**: Create a `Shape` class with a `calculateArea()` method. Create `Circle`, `Rectangle`, and `Triangle` subclasses that override this method.
+
+3. **RPG Characters**: Create a `Character` class. Extend it to make `Warrior`, `Mage`, and `Archer` classes with unique abilities.
+
+4. **Animal Sounds**: Create an `Animal` class with a `makeSound()` method. Create various animal subclasses that override this method.
diff --git a/content/docs/sq-AL/guides/learning-to-learn.mdx b/content/docs/sq-AL/guides/learning-to-learn.mdx
new file mode 100644
index 00000000..567e514e
--- /dev/null
+++ b/content/docs/sq-AL/guides/learning-to-learn.mdx
@@ -0,0 +1,37 @@
+---
+title: Learning to Learn
+description: A guide to help you become a better learner and adapt to new information effectively.
+icon: CircleQuestionMark
+---
+
+## Why learn to code? We have visual scripting!
+
+Yes we do, and honestly you should try that out. Visual scripting is a great addition to Hytale and we know it'll be powerful, but nothing beats the ability of being able to read and write Java code, with the ability to build even more powerful mods and plugins.
+
+<Callout type="info" title="Visual Scripting vs Coding">
+  Visual scripting is great for beginners and for simple tasks, but coding allows for more complex and efficient solutions. Learning to code opens up a wider range of possibilities for modding Hytale.
+
+  We will have guides on visual scripting when Hytale releases from Day 1.
+</Callout>
+
+## Should everyone trying to mod Hytale learn how to code?
+
+No one should feel like they HAVE to learn to code to make stuff in Hytale. Simon and his team have validated this time and time again with their strives in graph editors and visual scripting. You can change mob behavior, world generation, etc. all with just these tools.
+
+But if you're looking to build more complex things (from utilities to entirely custom server software) that could be used by large scale server networks and big names, you'll want to learn how to code. And that's where this guide comes in...
+
+## Okay, I'm interested. What's to come?
+
+Over the course of these next several lessons you'll learn the basics of coding, how to read documentation, and how to find resources to help you learn more on your own.
+
+The guides themselves will take a very big "bird's-eye view" approach to things and provide links to resources to do the actual coding. This is done because, quite frankly, enough resources exist on how to learn this stuff, it's just the act of finding the right stuff on Google that can be hard. Learning to be able to code without guidance is the goal. The Hytale Modding community is always there to help you, but to become a truly well rounded developer, you'll have to pick up a lot of this stuff just by reading from resources.
+
+<Callout type="info" title="Finding Resources">
+  We have created a small Java Basics series to help you get started with the language itself, but beyond that, you'll be expected to find your own resources to learn more. We recommend sites like [w3schools](https://www.w3schools.com/java/) and [GeeksforGeeks](https://www.geeksforgeeks.org/java/) as great starting points.
+</Callout>
+
+Our goal is to teach you how to Mod Hytale, and that will always be our goal. This is the reason we can't teach you everything about Java or programming in general. Instead, we want to give you the tools to be able to learn on your own, so you can continue to grow as a developer even after you've completed our guides.
+
+## Any closing thoughts?
+
+Remember, learning to code is hard. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come. Happy coding!
diff --git a/content/docs/sq-AL/guides/plugin/block-components.mdx b/content/docs/sq-AL/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/sq-AL/guides/plugin/browsing-serverjar.mdx b/content/docs/sq-AL/guides/plugin/browsing-serverjar.mdx
new file mode 100644
index 00000000..240ed19a
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/browsing-serverjar.mdx
@@ -0,0 +1,111 @@
+---
+title: Browsing the server.jar code
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
+---
+
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
+
+## Why?
+
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
+
+- Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
+  one of these:
+
+  - `python -m venv .venv`
+  - `python3 -m venv .venv` (Linux)
+  - `py -3.13 -m venv .venv` (Windows)
+
+  In the last one, specifying the version is recommended if you have multiple Pythons installed.
+
+- Activate the virtual environment:
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
+  - Linux/Mac: `source .venv/bin/activate`
+  - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
+
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
+  - `pip install -r requirements.txt`
+
+- Install these dependencies and ensure they are on PATH:
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
+  - `java` you need JDK 25 or newer
+  - `jar` (comes with JDK inside the bin folder)
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
+
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
+
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+
+Then run this:
+
+```shell
+python run.py setup
+```
+
+What will it do:
+
+- copy the HytaleServer.jar into `work/download`
+  - (on Windows) fix `META-INF/license` name collision
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
+- set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
+
+You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
+you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
+
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
+![_readme_images/img.png](/assets/reload-maven.png)\
+It is located in the "m" icon on the right side:\
+![_readme_images/m.png](/assets/maven.png)\
+If you don't see it, enable it under View -> Tool Windows -> Maven.\
+![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
diff --git a/content/docs/sq-AL/guides/plugin/build-and-test.mdx b/content/docs/sq-AL/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/sq-AL/guides/plugin/chat-formatting.mdx b/content/docs/sq-AL/guides/plugin/chat-formatting.mdx
new file mode 100644
index 00000000..c967fc0f
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/chat-formatting.mdx
@@ -0,0 +1,199 @@
+---
+title: Formatting the chat
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+![chat format example](/assets/guides/chat-example.png)
+
+The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
+You can cancel this event as well as modify the content and the formatter.
+
+## Manual Formatting (Standard Approach)
+
+```java
+public class ChatFormatter {
+
+  public static void onPlayerChat(PlayerChatEvent event) {
+    PlayerRef sender = event.getSender();
+    if(event.getContent().equalsIgnoreCase("poo")) {
+      event.setCancelled(true);
+      sender.sendMessage(Message.raw("Hey, you cannot say that!").color(Color.RED));
+    }
+
+    if(event.getContent().equalsIgnoreCase("you stink")) {
+      event.setContent("i stink");
+    }
+
+    event.setFormatter((playerRed, message) ->
+        Message.join(
+            Message.raw("[COOL] ").color(Color.RED),
+            Message.raw(sender.getUsername()).color(Color.YELLOW),
+            Message.raw(" : " + message).color(Color.PINK)
+        ));
+
+  }
+}
+```
+
+The formatter is the following interface:
+
+```java
+  public interface Formatter {
+    @Nonnull
+    Message format(@Nonnull PlayerRef playerRef, @Nonnull String message);
+  }
+}
+```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/sq-AL/guides/plugin/client-inputs-reference.mdx b/content/docs/sq-AL/guides/plugin/client-inputs-reference.mdx
new file mode 100644
index 00000000..a9f2f085
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/client-inputs-reference.mdx
@@ -0,0 +1,94 @@
+---
+title: "Packets: Client-to-Server Reference"
+description: Complete reference for every packet the client can send to the server.
+authors:
+  - name: Vibe Theory & musava
+    url: https://discord.com/users/145420279294722048
+---
+
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/sq-AL/guides/plugin/creating-block.mdx b/content/docs/sq-AL/guides/plugin/creating-block.mdx
new file mode 100644
index 00000000..07b909ad
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/creating-block.mdx
@@ -0,0 +1,101 @@
+---
+title: Creating custom blocks
+description: Learn how to create custom blocks for your Hytale mod.
+authors:
+  - name: Flo_12344
+    url: https://flotterstudio.com
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating custom blocks requires enabling asset packs and organizing your files properly.
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" />
+      </Folder>
+
+      <Folder name="Languages" defaultOpen>
+        <Folder name="en-US" />
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" />
+
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="my_new_block" defaultOpen>
+          <File name="model.blockymodel" />
+        </Folder>
+      </Folder>
+
+      <Folder name="BlockTextures" defaultOpen>
+        <File name="texture.png" />
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+3. Add translations in `Server/Languages/en-US/items.lang`:
+
+```
+my_new_block.name = My New Block
+my_new_block.description = My Description
+```
+
+## Basic Cube Block
+
+Create `Server/Item/Items/my_new_block.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "items.my_new_block.name",
+    "Description": "items.my_new_block.description"
+  },
+  "Id": "My_New_Block",
+  "MaxStack": 100,
+  "Icon": "Icons/ItemsGenerated/my_new_block.png",
+  "Categories": [
+    "Blocks.Rocks"
+  ],
+
+  "PlayerAnimationsId": "Block",
+  "Set": "Rock_Stone",
+  "BlockType": {
+    "Material": "Solid",
+    "DrawType": "Cube",
+    "Group": "Stone",
+    "Flags": {},
+    "Gathering": {
+      "Breaking": {
+        "GatherType": "Rocks",
+        "ItemId": "my_new_block"
+      }
+    },
+    "BlockParticleSetId": "Stone",
+    "Textures": [
+      {
+        "All": "BlockTextures/my_new_block.png"
+      }
+    ],
+    "ParticleColor": "#aeae8c",
+    "BlockSoundSetId": "Stone",
+    "BlockBreakingDecalId": "Breaking_Decals_Rock"
+  },
+  "ResourceTypes": [
+    {
+      "Id": "Rock"
+    }
+  ]
+}
+```
+
+Ensure all referenced files exist in their respective folders, and the paths are correct.
diff --git a/content/docs/sq-AL/guides/plugin/creating-commands.mdx b/content/docs/sq-AL/guides/plugin/creating-commands.mdx
new file mode 100644
index 00000000..f9881d9d
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/creating-commands.mdx
@@ -0,0 +1,421 @@
+---
+title: Creating Commands
+description: Learn how to create custom commands for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
+---
+
+In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
+
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
+
+To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
+
+You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
+
+You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
+
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
+```java
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType()); // also a component
+    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+    TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+    player.sendMessage(Message.raw("Player#getUuid() : " + player.getUuid())); // returns UUID from UUIDComponent
+    player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+    player.sendMessage(Message.raw("equal : " + player.getUuid().equals(component.getUuid()))); // they're both the same
+    player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+  }
+
+}
+```
+
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
+## Registering the Command
+
+For any command
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // One way to add commands
+        this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
+    }
+}
+```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/sq-AL/guides/plugin/creating-configuration-file.mdx b/content/docs/sq-AL/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/sq-AL/guides/plugin/creating-events.mdx b/content/docs/sq-AL/guides/plugin/creating-events.mdx
new file mode 100644
index 00000000..ea7abdc2
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/creating-events.mdx
@@ -0,0 +1,90 @@
+---
+title: Creating Events
+description: Learn how to create custom events for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: EllieAU
+    url: https://ellie.au
+---
+
+## Event Class
+
+You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+
+Example plugin when a player is ready (joins a server):
+
+```java
+
+public class ExampleEvent {
+
+    public static void onPlayerReady(PlayerReadyEvent event) {
+        Player player = event.getPlayer();
+        player.sendMessage(Message.raw("Welcome " + player.getDisplayName()));
+    }
+
+}
+```
+
+## Registering the Event
+
+You need to register all events you make in the Main plugin class, usually in the `setup` function.
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        this.getEventRegistry().registerGlobal(PlayerReadyEvent.class, ExampleEvent::onPlayerReady);
+    }
+}
+```
+
+## ECS Event Classes
+
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
+
+```java
+class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent.Pre> {
+    public ExampleCancelCraft() {
+        super(CraftRecipeEvent.Pre.class);
+    }
+
+    @Override
+    public void handle(int index,
+                       @NonNullDecl ArchetypeChunk<EntityStore> archetypeChunk,
+                       @NonNullDecl Store<EntityStore> store,
+                       @NonNullDecl CommandBuffer<EntityStore> commandBuffer,
+                       @NonNullDecl CraftRecipeEvent.Pre craftRecipeEvent) {
+        CraftingRecipe recipe = craftRecipeEvent.getCraftedRecipe();
+        if (recipe.getInput() != null) {
+            for (MaterialQuantity mq : recipe.getInput()) {
+                if (Objects.equals(mq.getItemId(), "Ingredient_Fibre")) {
+                    craftRecipeEvent.setCancelled(true);
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Archetype.empty();
+    }
+}
+```
+
+## Registering ECS Events
+
+You will need to register the system in your plugin:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        this.getEntityStoreRegistry().registerSystem(new ExampleCancelCraft());
+    }
+}
+```
diff --git a/content/docs/sq-AL/guides/plugin/customizing-camera-controls.mdx b/content/docs/sq-AL/guides/plugin/customizing-camera-controls.mdx
new file mode 100644
index 00000000..e98c7777
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/customizing-camera-controls.mdx
@@ -0,0 +1,170 @@
+---
+title: Customizing Camera Controls
+description: Intro to custom camera modding.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+## The Basics
+
+Hytale provides great camera customizability! Heres the essentials to get started.
+
+Camera is controlled by sending a `SetServerCamera` packet with `ServerCameraSettings`:
+
+```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)
+);
+```
+
+This gives you a simple third-person camera. The presets below show more complete configurations.
+
+**Reset to default:**
+
+```java
+playerRef.getPacketHandler().writeNoCache(
+    new SetServerCamera(ClientCameraView.Custom, false, null)
+);
+```
+
+---
+
+## Camera Presets
+
+### Top-Down (RTS/ARPG Style)
+
+_Source: `com.hypixel.hytale.server.core.command.commands.player.camera.PlayerCameraTopdownCommand`_
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.distance = 20.0f;
+settings.displayCursor = true;
+settings.isFirstPerson = false;
+settings.movementForceRotationType = MovementForceRotationType.Custom;
+// Align movement with camera yaw (horizontal rotation only)
+settings.movementForceRotation = new Direction(-0.7853981634f, 0.0f, 0.0f);  // 45° left
+settings.eyeOffset = true;
+settings.positionDistanceOffsetType = PositionDistanceOffsetType.DistanceOffset;
+settings.rotationType = RotationType.Custom;
+settings.rotation = new Direction(0.0f, -1.5707964f, 0.0f);  // Look straight down
+settings.mouseInputType = MouseInputType.LookAtPlane;
+settings.planeNormal = new Vector3f(0.0f, 1.0f, 0.0f);       // Ground plane
+```
+
+### Side-Scroller (2D Platformer Style)
+
+_Source: `com.hypixel.hytale.server.core.command.commands.player.camera.PlayerCameraSideScrollerCommand`_
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.distance = 15.0f;
+settings.displayCursor = true;
+settings.isFirstPerson = false;
+settings.movementForceRotationType = MovementForceRotationType.Custom;
+settings.movementMultiplier = new Vector3f(1.0f, 1.0f, 0.0f);  // Lock Z-axis
+settings.eyeOffset = true;
+settings.positionDistanceOffsetType = PositionDistanceOffsetType.DistanceOffset;
+settings.rotationType = RotationType.Custom;
+settings.mouseInputType = MouseInputType.LookAtPlane;
+settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
+```
+
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
+## Common Settings Explained
+
+### Position & Rotation
+
+- **`positionLerpSpeed`** (0.0-1.0): How smoothly the camera follows the player. Lower = smoother but slower response.
+- **`rotationLerpSpeed`** (0.0-1.0): How smoothly the camera rotates. Lower = smoother but slower response.
+- **`distance`**: Camera distance from player. Higher = zoomed out more.
+- **`rotation`**: Camera angle as `Direction(yaw, pitch, roll)` in radians.
+- **`rotationType`**: How rotation is calculated. `RotationType.Custom` uses your `rotation` value.
+
+### Movement Alignment
+
+- **`movementForceRotationType`**:
+- `MovementForceRotationType.AttachedToHead` = movement follows where player looks
+- `MovementForceRotationType.Custom` = use `movementForceRotation` value
+- **`movementForceRotation`**: When using `Custom`, this sets the direction for W/S movement. Match yaw with camera but keep pitch at 0.
+
+### Input & Display
+
+- **`displayCursor`**: Show/hide mouse cursor.
+- **`mouseInputType`**:
+- `MouseInputType.LookAtPlane` = mouse moves cursor on a plane (good for top-down)
+- `MouseInputType.LookAtTarget` = mouse rotates camera
+- **`planeNormal`**: For `LookAtPlane`, defines which plane the mouse moves on. `(0,1,0)` = ground plane.
+
+### Advanced
+
+- **`positionDistanceOffsetType`**:
+- `DistanceOffset` = simple distance offset
+- `DistanceOffsetRaycast` = prevents camera clipping through walls
+- **`eyeOffset`**: Offset camera from player's eye position.
+- **`movementMultiplier`**: Scale movement on each axis. `(1,1,0)` = lock Z-axis for 2D movement.
+
+---
+
+## Imports
+
+```java
+import com.hypixel.hytale.protocol.ClientCameraView;
+import com.hypixel.hytale.protocol.Direction;
+import com.hypixel.hytale.protocol.MouseInputType;
+import com.hypixel.hytale.protocol.MovementForceRotationType;
+import com.hypixel.hytale.protocol.PositionDistanceOffsetType;
+import com.hypixel.hytale.protocol.RotationType;
+import com.hypixel.hytale.protocol.ServerCameraSettings;
+import com.hypixel.hytale.protocol.Vector3f;
+import com.hypixel.hytale.protocol.packets.camera.SetServerCamera;
+```
+
+---
+
+## Tips
+
+- **Zoom:** Adjust `distance` (higher = further out)
+- **Smoothness:** `positionLerpSpeed` and `rotationLerpSpeed` control how quickly the camera catches up to its target
+- **Wall clipping:** Use `PositionDistanceOffsetType.DistanceOffsetRaycast`
+- **Lock camera:** Set `isLocked = true` in the packet to prevent player changes
+- **2D movement:** Set `movementMultiplier` to zero out an axis
+- **Isometric cameras:** Always set `movementForceRotation` to match camera yaw for proper movement alignment
+- **Angle calculations:** Use `Math.toRadians(degrees)` or `degrees * Math.PI / 180.0` to convert degrees to radians
+
+---
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/sq-AL/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/sq-AL/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/sq-AL/guides/plugin/instances.mdx b/content/docs/sq-AL/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/sq-AL/guides/plugin/inventory-management.mdx b/content/docs/sq-AL/guides/plugin/inventory-management.mdx
new file mode 100644
index 00000000..e38c644f
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/inventory-management.mdx
@@ -0,0 +1,125 @@
+---
+title: Inventory Management
+description: Learn how to manage player inventories in your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+---
+
+In this guide, you'll learn how to manage player inventories in your Hytale mod.
+
+## Accessing the Player Inventory
+
+To access the Inventory of a `Player`, you can use the `getInventory()` method which returns the `Inventory` object.
+
+```java
+Inventory inventory = player.getInventory();
+```
+
+## Opening Inventories
+
+You can open different types of inventories, these inventories are known as "Pages". You can also add custom pages, this will be covered in a guide later on.
+
+You can use the `Page` enum to reference existing inventories, currently the following pages are available:
+
+- `Page.None`
+- `Page.Bench`
+- `Page.Inventory`
+- `Page.ToolsSettings`
+- `Page.Map`
+- `Page.MachinimaEditor`
+- `Page.ContentCreation`
+- `Page.Custom`
+
+```java
+PageManager pageManager = player.getPageManager();
+Store<EntityStore> store = player.getWorld().getEntityStore().getStore();
+pageManager.setPage(player.getReference(), store, Page.Inventory);
+```
+
+## `ItemStack` Class
+
+You can create and manipulate items in a player's inventory using the `ItemStack` class. This class represents a stack of items, and provides methods for managing the quantity and type of items in the stack.
+
+### Creating an ItemStack
+
+To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
+
+```java
+ItemStack item = new ItemStack("Stone");
+ItemStack withQuantity = new ItemStack("Stone", 64);
+```
+
+#### Adding custom metadata
+
+You can also add custom metadata to a `ItemStack` by passing a `BsonDocument` when creating it.
+
+```java
+BsonDocument metadata = new BsonDocument();
+metadata.append("customData", new BsonString("value"));
+ItemStack item = new ItemStack("Stone", 64, metadata);
+```
+
+### Setting a durability
+
+```java
+ItemStack stackWithDurability = new ItemStack(
+    "DiamondSword", // itemId
+    1,              // quantity
+    100.0,          // durability
+    100.0,          // maxDurability
+    metadata        // metadata (optional)
+);
+```
+
+## Getting the `ItemContainer`
+
+The `Inventory` class provides methods to get multiple `ItemContainer` objects, like:
+
+- `.getStorage()`
+- `.getArmor()`
+- `.getBackpack()`
+- `.getHotbar()`
+- `.getUtility()`
+
+There are also combined methods like:
+
+- `.getCombinedEverything()`
+- `.getCombinedArmorHotbarStorage()`
+- `.getCombinedBackpackStorageHotbar()`
+- `.getCombinedHotbarFirst()`
+- `.getCombinedStorageFirst()`
+- `.getCombinedArmorHotbarUtilityStorage()`
+- `.getCombinedHotbarUtilityConsumableStorage()`
+
+## Adding `ItemStack` objects to the Inventory
+
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
+
+```java
+Inventory inventory = player.getInventory();
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
+```
+
+Or you can specify a certain slot to add it to:
+
+```java
+storageContainer.addItemStackToSlot((short) 4, stack)
+```
+
+## Removing `ItemStack` objects from the Inventory
+
+To remove an `ItemStack` from a player's inventory, you can use the `removeItemStack()` method of the `Inventory` class.
+
+```java
+Inventory inventory = player.getInventory();
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
+```
+
+Or you can specify a certain slot to remove it from:
+
+```java
+storageContainer.removeItemStackFromSlot((short) 4);
+```
diff --git a/content/docs/sq-AL/guides/plugin/item-interaction.mdx b/content/docs/sq-AL/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/sq-AL/guides/plugin/listening-to-packets.mdx b/content/docs/sq-AL/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/sq-AL/guides/plugin/logging.mdx b/content/docs/sq-AL/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/sq-AL/guides/plugin/permission-management.mdx b/content/docs/sq-AL/guides/plugin/permission-management.mdx
new file mode 100644
index 00000000..70aef22c
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/permission-management.mdx
@@ -0,0 +1,118 @@
+---
+title: Permission Management
+description: Learn how to manage permission nodes and groups in your Hytale plugin.
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: Craw
+    link: https://discord.com/users/292656109939064833
+---
+
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+
+## The `PermissionsModule` class
+
+The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+
+- Add permissions to user
+- Remove permissions from user
+- Add permissions to group (this also creates the group if it doesn't exist)
+- Remove permissions from group
+- Add user to group
+- Remove user from group
+- List all groups for a user
+- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+
+With this class you cannot:
+
+- List all defined groups
+- Remove a group
+
+### Adding Permission Nodes
+
+You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+
+```java
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addUserPermission(playerUUID, permissions);
+```
+
+### Removing Permission Nodes
+
+Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+
+```java
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeUserPermission(playerUUID, permissions);
+```
+
+### Add permissions to group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addGroupPermission(groupName, permissions);
+```
+
+### Remove permissions from group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeGroupPermission(groupName, permissions);
+```
+
+### Add user to group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.addUserToGroup(playerUUID, groupName);
+```
+
+### Remove user from group
+
+```java
+String groupName = "testGroup";
+Set<String> permissions = new HashSet<>();
+PermissionsModule perms = PermissionsModule.get();
+perms.removeUserFromGroup(playerUUID, groupName);
+```
+
+### List all groups for a user
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+perms.getGroupsForUser(playerUUID);
+```
+
+### Check Permission Nodes
+
+To check if a player has a specific permission node, you can use the `hasPermission` method.
+
+```java
+boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+```
+
+### Additional: Defining your own storage provider for permissions and groups
+
+Apparently we could implement our own storage provider for permissions and groups as file storage is not very reliable.
+
+First we need to define a provider class that implements PermissionProvider:
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider
+```
+
+Then we just implement the required methods using a database implementation. To force our plugin to use this new provider we just need to add to the provider list our fresh DatabasePermissionProvider.
+
+```java
+perms.getProviders().addFirst(new DatabasePermissionProvider());
+```
diff --git a/content/docs/sq-AL/guides/plugin/player-death-event.mdx b/content/docs/sq-AL/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/sq-AL/guides/plugin/player-input-guide.mdx b/content/docs/sq-AL/guides/plugin/player-input-guide.mdx
new file mode 100644
index 00000000..c9cc1419
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/player-input-guide.mdx
@@ -0,0 +1,68 @@
+---
+title: Player Input Guide
+description: Learn how to handle player input.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
+---
+
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
+
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
+
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
+
+```java
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
+        }
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
+        }
+    }
+}
+```
+
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/sq-AL/guides/plugin/player-stats.mdx b/content/docs/sq-AL/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/sq-AL/guides/plugin/playing-sounds.mdx b/content/docs/sq-AL/guides/plugin/playing-sounds.mdx
new file mode 100644
index 00000000..7ce614b8
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/playing-sounds.mdx
@@ -0,0 +1,64 @@
+---
+title: Playing Sounds
+description: Learn how to Play Sounds with your Hytale Plugin
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+In this guide, you will learn how to play sounds to a player.
+
+## Sound Indexes
+
+We currently have a lot of Sounds available to be used as a key in the AssetMap, [click here](../../server/sounds) to see the full list of available sounds.
+
+You can use the `getAssetMap()` method from the `SoundEvent` class to get the index of a specified sound:
+
+```java
+int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
+```
+
+## The Transform Component
+
+The `TransformComponent` is the component that tells Hytale where to play the sound. You can get this in multiple ways.
+
+1. Getting the Transform Component from the `Player` object
+
+```java
+TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+```
+
+2. Generating a new TransformComponent (although this is not recommended, as if your player is not close enough they won't hear the sound)
+
+```java
+Vector3d vector3d = new Vector3d(0, 0, 0); // position
+Vector3f vector3f = new Vector3f(0, 0, 0); // rotation
+TransformComponent transform = new TransformComponent(vector3d, vector3f);
+```
+
+### PlayerRef
+
+You need a Player Reference, which is a instance of `Ref<EntityStore>`. If you have the `Player` object, you can use the `getReference()` method to get a Player Reference
+
+### World
+
+You need a World reference, as the sound needs to be played inside the `execute()` method from the `World` class.
+
+### SoundCategory
+
+There is a `SoundCategory` enum that defines different sound categories, such as `Music`, `Ambient`, `SFX` and `UI`. You can use these categories to specify the type of sound you are playing.
+
+## Playing Sounds
+
+You can use the `SoundUtil` class to play sounds, using the `playSoundEvent3dToPlayer` method.
+
+```java
+int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
+World world = player.getWorld();
+EntityStore store = world.getEntityStore();
+Ref<EntityStore> playerRef = player.getReference();
+world.execute(() -> {
+    TransformComponent transform = store.getStore().getComponent(playerRef, EntityModule.get().getTransformComponentType());
+    SoundUtil.playSoundEvent3dToPlayer(playerRef, index, SoundCategory.UI, transform.getPosition(), store.getStore());
+});
+```
diff --git a/content/docs/sq-AL/guides/plugin/send-notifications.mdx b/content/docs/sq-AL/guides/plugin/send-notifications.mdx
new file mode 100644
index 00000000..8eafb96e
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/send-notifications.mdx
@@ -0,0 +1,48 @@
+---
+title: Sending notifications
+description: Learn how to send notifications (similar to item pickup) with your Hytale Plugin
+authors:
+  - name: BeerBag
+---
+
+## Overview
+
+In this guide, you will learn how to send notifications to players, similar to
+the notification received when picking up an item from the ground.
+
+![notification-example](/assets/guides/notification-example.png)
+
+## Structure of a Notification
+
+A notification consists of three main components:
+
+1. **Primary Message**: The main `Message` displayed in the notification.
+2. **Secondary Message**: Additional `Message`, displayed below the primary message.
+3. **Icon**: An item icon that visually represents the notification, shown on
+   the left side.
+
+## Sending Notifications
+
+You can use the `NotificationUtil` class to send notifications to players.
+You will need access to the `PacketHandler` of the player, which can be obtained
+from the `PlayerRef` using the `getPacketHandler()` method (in this example,
+we get the `PlayerRef` from the `Universe` using the player's UUID).
+
+```java
+public static void onPlayerReady(PlayerReadyEvent event) {
+    var player = event.getPlayer();
+
+    var playerRef = Universe.get().getPlayer(player.getUuid());
+    var packetHandler = playerRef.getPacketHandler();
+
+    var primaryMessage = Message.raw("THIS WORKS!!!").color("#00FF00");
+    var secondaryMessage = Message.raw("This is the secondary message").color("#228B22");
+    var icon = new ItemStack("Weapon_Sword_Mithril", 1).toPacket();
+
+    NotificationUtil.sendNotification(
+        packetHandler,
+        primaryMessage,
+        secondaryMessage,
+        (ItemWithAllMetadata) icon);
+}
+```
diff --git a/content/docs/sq-AL/guides/plugin/setting-up-env.mdx b/content/docs/sq-AL/guides/plugin/setting-up-env.mdx
new file mode 100644
index 00000000..8115e634
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/setting-up-env.mdx
@@ -0,0 +1,170 @@
+---
+title: Setting Up Your Development Environment
+description: Learn how to set up your development environment for modding Hytale.
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
+This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
+
+## Prerequisites
+
+Before we begin, make sure you have:
+
+- A computer running Windows 10/11, macOS, or Linux
+- At least 8GB of RAM
+- 10GB of free disk space
+- Administrative privileges on your system
+
+## Required Software
+
+### 1. Java Development Kit (JDK)
+
+Hytale modding requires Java 25 or later. We recommend using OpenJDK.
+
+#### Windows
+
+1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
+2. Run the installer with default settings
+3. Verify installation by opening Command Prompt and running:
+
+```bash
+java -version
+```
+
+#### macOS
+
+```bash
+# Using Homebrew
+brew install openjdk@25
+```
+
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
+#### Linux (Ubuntu/Debian)
+
+```bash
+sudo apt update
+sudo apt install openjdk-25-jdk
+```
+
+### 2. Integrated Development Environment (IDE)
+
+We recommend IntelliJ IDEA Community Edition for Hytale modding.
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+
+1. Visit the official website: https://maven.apache.org/download.cgi
+2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `apache-maven-3.9.12/bin/` folder to your PATH
+
+You can now try the command `mvn -version` to verify Maven is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+## Setting Up Your Workspace
+
+### 1. Clone the Plugin Template
+
+Instead of creating an empty directory, we'll use the official Hytale plugin template:
+
+```bash
+# Clone the template repository
+git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
+cd MyFirstMod
+```
+
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
+
+1. Open IntelliJ IDEA
+2. Click "Open" and navigate to your `MyFirstMod` directory
+3. IntelliJ will automatically detect it as a Maven project
+4. Wait for the project to index and dependencies to download
+
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
+## Next Steps
+
+Now that you have your development environment set up with the plugin template:
+
+1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+2. **Explore the code structure** - Familiarize yourself with the template's organization
+3. **Start modding** - Begin writing your first Hytale plugin!
+
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
+
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/sq-AL/guides/plugin/spawning-entities.mdx b/content/docs/sq-AL/guides/plugin/spawning-entities.mdx
new file mode 100644
index 00000000..e12c0aea
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/spawning-entities.mdx
@@ -0,0 +1,120 @@
+---
+title: Spawning Entities
+description: Learn how to spawn Entities in Hytale
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+In this guide, you will learn how to spawn entities in Hytale. It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding with this guide. You can find the ECS guide [here](./ecs).
+
+## Getting the World Object
+
+You need to first get the `World` object before proceeding with spawning entities. You can get this object in a few ways:
+
+### Using the `Player` Object
+
+You can use the `Player` object to get the `World` object by calling the `getWorld()` method on the `Player` instance.
+
+```java
+World world = player.getWorld();
+```
+
+### Using the `Universe` Class
+
+You can use the `Universe` class to get the `World` object by calling the `getWorld(string UUID)` method on the `Universe` instance.
+
+```java
+World world = Universe.get().getWorld("your-world-uuid");
+```
+
+Once you have the world object, you need to get a instance of `Store<EntityStore>`, you can do so by:
+
+```java
+Store<EntityStore> store = world.getEntityStore().getStore();
+```
+
+## Creating Entities
+
+Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+
+<Callout type="warning">
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
+
+  ```java
+  world.execute(() -> {
+      // run all the code below in this context
+  })
+  ```
+</Callout>
+
+Let's start by creating a blank holder:
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+```
+
+## Getting a Model
+
+You now need a model for your Entity. You can find a list of all entities [here](../../server/entities), we're going to use the Minecart entity for this example:
+
+```java
+ModelAsset modelAsset = ModelAsset.getAssetMap().getAsset("Minecart");
+Model model = Model.createScaledModel(modelAsset, 1.0f);
+```
+
+### The Transform Component
+
+The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
+
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
+
+```java
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
+```
+
+2. Generating a new TransformComponent
+
+```java
+Vector3d vector3d = new Vector3d(0, 0, 0); // position
+Vector3f vector3f = new Vector3f(0, 0, 0); // rotation
+TransformComponent transform = new TransformComponent(vector3d, vector3f);
+```
+
+## Adding Components to our Entity
+
+Now we need to add all the components we made above to our entity, here's all the components we need to add one by one:
+
+```java
+
+holder.addComponent(TransformComponent.getComponentType(), new TransformComponent(vector3d, new Vector3f(0, 0, 0)));
+holder.addComponent(PersistentModel.getComponentType(), new PersistentModel(model.toReference()));
+holder.addComponent(ModelComponent.getComponentType(), new ModelComponent(model));
+holder.addComponent(BoundingBox.getComponentType(), new BoundingBox(model.getBoundingBox()));
+holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+holder.addComponent(Interactions.getComponentType(), new Interactions()); // you need to add interactions here if you want your entity to be interactable
+```
+
+### Ensuring Hytale's Components are present
+
+These act as "configuration" or "default" components that Hytale expects to be present on all entities.
+
+```java
+holder.ensureComponent(UUIDComponent.getComponentType());
+holder.ensureComponent(Interactable.getComponentType()); // if you want your entity to be interactable
+```
+
+## Spawning the Entity
+
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
+
+```java
+store.addEntity(holder, AddReason.SPAWN);
+```
diff --git a/content/docs/sq-AL/guides/plugin/spawning-npcs.mdx b/content/docs/sq-AL/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/sq-AL/guides/plugin/store-persistant-data.mdx b/content/docs/sq-AL/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/sq-AL/guides/plugin/teleporting-players.mdx b/content/docs/sq-AL/guides/plugin/teleporting-players.mdx
new file mode 100644
index 00000000..57cee77f
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/teleporting-players.mdx
@@ -0,0 +1,26 @@
+---
+title: Teleporting the player
+description: Learn how to teleport the player.
+---
+
+To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
+Next, we get the entity store and make a `Teleport` object.
+We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+
+```java
+public static void teleportPlayer(Player player, int x, int y, int z) {
+        World world = player.getWorld();
+        if (world == null) return;
+        world.execute(() -> {
+            if (player.getReference() == null) return;
+            Store<EntityStore> store = player.getReference().getStore();
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
+
+            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
+        });
+
+}
+```
diff --git a/content/docs/sq-AL/guides/plugin/text-hologram.mdx b/content/docs/sq-AL/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/sq-AL/guides/plugin/ui.mdx b/content/docs/sq-AL/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/sq-AL/guides/plugin/world-gen.mdx b/content/docs/sq-AL/guides/plugin/world-gen.mdx
new file mode 100644
index 00000000..4c23b0c9
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/world-gen.mdx
@@ -0,0 +1,143 @@
+---
+title: World Generation System
+description: Learn how to create custom world generation features for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+---
+
+# Overview
+
+This section covers Hytale's procedural world generation systems that creates environments, biomes, and structures dynamically as players explore the world.
+
+Hytale’s world generation is organized into three interconnected systems:
+
+- **Zones** - Large-scale regions that define overall world structure
+- **Biomes** - Terrain characteristics and environmental properties within zones
+- **Caves** - Underground structures and networks generated within zones
+
+These systems work together to create a rich, varied world with smooth transitions and coherent regional themes.
+
+## Getting Started
+
+1. Zone System - Large regions
+2. Biome System - Terrain and environment within zones
+3. Cave System - Underground structures and networks within zones
+
+## Implementation Details
+
+### Zone Lookup and Generation
+
+```java
+
+// Get zone at position
+ZonePatternGenerator zoneGen = /* world generator */;
+ZoneGeneratorResult zoneResult = zoneGen.generate(seed, x, z);
+Zone zone = zoneResult.getZone();
+
+// Get biome within zone
+BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
+Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
+
+// Check for caves in zone
+CaveGenerator caveGen = zone.caveGenerator();
+if (caveGen != null) {
+    CaveType[] caveTypes = caveGen.getCaveTypes();
+    // Generate caves as needed
+}
+```
+
+### Creating a Custom Zone
+
+```java
+// Configure zone discovery
+ZoneDiscoveryConfig discovery = new ZoneDiscoveryConfig(
+    true,                           // Show notification
+    "Custom Zone",                  // Display name
+    "zone.forest.discover",         // Sound event
+    "icons/forest.png",             // Icon
+    true,                           // Major zone
+    5.0f, 2.0f, 1.5f                // Duration, fade in, fade out
+);
+
+// Create biome pattern
+IPointGenerator biomePoints;
+IWeightedMap<TileBiome> tileBiomes;
+CustomBiome[] customBiomes;
+
+BiomePatternGenerator biomeGen = new BiomePatternGenerator(
+    biomePoints,
+    tileBiomes,
+    customBiomes
+);
+
+// Create cave configuration
+CaveType[] caveTypes; // cave definitions
+CaveGenerator caveGen = new CaveGenerator(caveTypes);
+
+// Assemble the zone
+Zone customZone = new Zone(
+    100,                    // Unique ID
+    "new_custom_zone",      // Internal name
+    discovery,              // Discovery config
+    caveGen,                // Cave generator
+    biomeGen,               // Biome pattern
+    uniquePrefabs           // Unique structures
+);
+```
+
+## System Integration
+
+### Zone & Biome Integration
+
+Each zone defines its own biome pattern:
+
+```java
+Zone zone = zoneGen.generate(seed, x, z).getZone();
+BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
+Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
+```
+
+### Zone & Cave Integration
+
+Each zone defines it's own cave patterns:
+
+```java
+Zone zone = /* ... */;
+CaveGenerator caveGen = zone.caveGenerator();
+if (caveGen != null) {
+    // This zone has caves
+    CaveType[] types = caveGen.getCaveTypes();
+}
+```
+
+### Biome & Cave Integration
+
+Caves use biome masks for placement control:
+
+```java
+// Cave type with biome restrictions
+Int2FlagsCondition biomeMask = caveType.getBiomeMask();
+int biomeId = biome.getId();
+int flags = biomeMask.eval(biomeId);
+
+// Check if cave can generate in this biome
+if (CaveBiomeMaskFlags.canGenerate(flags)) {
+    // Generate cave
+}
+```
+
+### Border Transitions
+
+All systems respect zone boundaries:
+
+```java
+ZoneGeneratorResult result = zoneGen.generate(seed, x, z);
+double borderDistance = result.getBorderDistance();
+
+// Fade custom biomes near borders
+if (borderDistance < customBiome.getFadeContainer().getMaskFadeSum()) {
+    double factor = customBiome.getFadeContainer().getMaskFactor(result);
+    // Apply fading
+}
+```
diff --git a/content/docs/sq-AL/guides/prefabs.mdx b/content/docs/sq-AL/guides/prefabs.mdx
new file mode 100644
index 00000000..08404b30
--- /dev/null
+++ b/content/docs/sq-AL/guides/prefabs.mdx
@@ -0,0 +1,92 @@
+---
+title: Prefabs
+description: Documentation about Prefabs in Hytale.
+icon: Box
+authors:
+  - name: Ben Cressman
+    url: https://bencres.dev
+---
+
+# Introduction
+
+Prefabs are Hytale's way of creating reusable structures.
+
+There are a few fundamental concepts to understand about prefabs:
+
+- Users interact with prefabs via a prefab editing world.
+- Prefabs the physical structures in the game world, and are saved as JSON files.
+
+## How to Create a Prefab
+
+Be sure to check the Known Issues section at the end of this guide if you encounter any problems.
+
+1. `/editprefab new <world name>` to create a new prefab editing world: `/editprefab new my_prefab_world`
+   - Note that `my_prefab` is the name of the _world_, not the prefab itself. Worlds can contain multiple prefabs.
+2. Build whatever you want in the prefab editing world.
+3. Use the selection brush to select the area you want to save as a prefab.
+4. `/prefab save` to save the structure as a prefab.
+5. `/editprefab exit` to exit the prefab editing world.
+6. Using the Paste brush, press 'e' on your keyboard to select the prefab you just created. It will be in the "server" dropdown, which can be selected from the top right of the menu.
+   - You can also select it with `/prefab list` and selecting the prefab you just created.
+
+There is a lot more that you can do with prefabs; this is just the basic flow. Keep reading for more information.
+
+## Commands
+
+There are two main commands for prefabs, `/prefab` and `/editprefab`.
+
+This list does not cover the various options for each command. You can use the `--help` flag at the end of any command to see the available options, e.g. `/prefab save --help`, or use `/help` in game and find the `prefab` and `editprefab` commands.
+
+### `/prefab`
+
+This command allows the user to interact with an existing prefab's file.
+
+Subcommands:
+
+- `save`
+  - Saves the prefab to the file system.
+- `load`
+  - Loads the prefab into the game.
+- `delete`
+  - Deletes the prefab from the file system.
+- `list`
+  - Lists all prefabs in the file system.
+
+### `/editprefab`
+
+The `/editprefab` command is used to create or edit the physical structure in the game the prefab is holding.
+
+Subcommands:
+
+- `exit`
+  - Exits the current prefab editing world.
+- `load`
+  - Creates a new prefab editing world to paste an existing prefab into.
+- `new`
+  - Creates a new prefab editing world to create a new prefab from scratch.
+- `select`
+  - Selects the area of the prefab the user is looking at (within 200 blocks).
+- `save`
+  - Saves the current prefab using the existing area, or the currently selected area.
+- `saveui`
+  - Opens the save UI for the current world, allowing the user to interact with all prefabs that are in the world.
+- `kill`
+  - Despawn all entities in the currently selected prefab.
+- `saveas`
+  - Save the selected prefab into a new file.
+- `setbox`
+  - Set the bounding box of the currently selected prefab.
+- `info`
+  - General information about the currently selected prefab.
+- `tp`
+  - Opens the teleport UI to teleport to a prefab in the current editing world.
+- `modified`
+  - Lists all modified prefabs with unsaved changes in the current editing world.
+
+# Known Issues
+
+- After saving edits to an existing prefab, the prefab does not reflect the changes in the game.
+  - Workaround: exit and re-enter the world.
+- When pasting a prefab, the prefab is not always shown accurately.
+  - Workaround: hit 't' on your keyboard to toggle the material being shown; usually at least one view is accurate.
+- `/prefab delete` errors with `Assert not in thread`.
diff --git a/content/docs/sq-AL/index.mdx b/content/docs/sq-AL/index.mdx
new file mode 100644
index 00000000..e09ace85
--- /dev/null
+++ b/content/docs/sq-AL/index.mdx
@@ -0,0 +1,19 @@
+---
+title: Introduction
+description: Necessary knowledge for modding Hytale.
+---
+
+Hytale is a voxel-based sandbox RPG game by **Hypixel Studios**, as described on the [Hytale website](https://hytale.com/):
+
+> Set out on an adventure built for both creation and play. Hytale blends the freedom
+> of a sandbox with the momentum of an RPG: explore a procedurally generated world full
+> of dungeons, secrets, and a variety of creatures, then shape it block by block.
+
+Hytale has been built from the ground up with modding and user-generated content in mind.
+The goal of **Hytale Modding** is to provide an excellent resource such that anybody
+is able to mod Hytale for themselves, regardless of skill level or specialization.
+
+It is important to note that modding Hytale is not restricted to programming plugins.
+Programming, visual scripting, texturing, 3D modelling, modifying assets, etc. are all modding.
+
+<u>In Hytale, anyone can be a modder.</u>
diff --git a/content/docs/sq-AL/official-documentation/npc-doc.mdx b/content/docs/sq-AL/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/sq-AL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/sq-AL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/sq-AL/publishing/builtbybit.mdx b/content/docs/sq-AL/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/sq-AL/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/sq-AL/publishing/curseforge.mdx b/content/docs/sq-AL/publishing/curseforge.mdx
new file mode 100644
index 00000000..d97327d5
--- /dev/null
+++ b/content/docs/sq-AL/publishing/curseforge.mdx
@@ -0,0 +1,71 @@
+---
+title: CurseForge
+description: Learn how to publish your mod to CurseForge
+---
+
+CurseForge is a mod hosting platform, allowing you to share your Hytale mods and creations with players via our website and app.
+
+## 1. Create CurseForge Account
+
+First, [visit our sign-in page](https://curseforge.com/api/v1/auth/login?returnUrl=https://www.curseforge.com/) and either log in to an existing account or click “Create an account”.
+
+This can be done using any Google, Discord, GitHub or Twitch account.
+
+## 2. Create a Project
+
+Now that you're logged in, you can visit our Author Console and navigate to the Projects tab, then click “Create a Project”, either in the sidebar or at the top of the page.
+
+![CurseForge Author Page](/assets/guides/curseforge_author_page.png)
+
+This will then take you to the [project creation](https://authors.curseforge.com/#/projects/create/choose-game) flow. First, select your game (in this case, Hytale) for and the page will be updated with new fields waiting for your inputs. Please see our
+
+[Moderation Policies](https://support.curseforge.com/en/support/solutions/articles/9000197279-moderation-policies#:~:text=General%20CurseForge%20Moderation%20Policies,-Policy\&text=The%20description%20can%20include%20descriptive,the%20game%22%20is%20not%20enough) articles for more information about what is and isn't allowed when creating a new project. Below are the fields along with their descriptions:
+
+- **Name:** This is the title of your project. It should be unique to your project. If the name is already taken, it will be rejected.
+- **Summary:** This is a short blurb about the mod that will show up in the project listings
+- **Description:** This is the longer explanation of what your mod does/adds. Make sure you clearly elaborate on your project. We will reject your project if the description is not grammatically correct or if it does not sufficiently describe the project you are creating. This can be edited later. Note: All titles and descriptions must be in English.
+- **Project License:** This is a drop-down field that contains the most common licenses used in modding games. Research the license type you want to use, including its pros and cons. You can also choose to use a Custom License at the bottom of the dropdown list and enter any text you want.
+- **Class:** This is the root category for your project. Ensure you select the correct one, as it may impact supported file types and app support in CurseForge.
+  - For Hytale, there are four types of Class:
+    - Mods
+      - This is the class that contains both Asset Packs and Plugins, and you should upload either here.
+    - Worlds
+    - Prefabs
+    - Bootstrap
+      - This is the class that contains all Early Plugins.
+- **Main Category:** This is the primary category into which your project will be sorted.
+- **Additional categories:** You can add up to 4 of these. Your project will also show up in lists where people are searching for these types of mods. Be careful, though, if you just add categories that have nothing to do with your mod, we may send it back to you for changes.
+- **Logo Image:** A unique icon to identify your project by.
+
+## 3. Upload a File
+
+Once you've set up your project and filled in the above information, you now need to upload a file to your project for it to enter the moderation queue. To do this, visit the “Files” tab in your Author Console page.
+
+![CurseForge Add Project](/assets/guides/curseforge_add_project.png)
+
+Then, click on “Add File” and upload your mod's file, entering any additional information or meta you wish to include regarding this file.
+
+The file format will depend on the class you select.
+
+### For Plugins
+
+If you're uploading a plugin for Hytale, please make sure you select the "Mods" class and upload your file as a jar file.
+
+### For Packs
+
+If you're uploading a Pack for Hytale, please make sure you select the "Mods" class and upload your file as a ZIP file
+
+### For Worlds
+
+If you're uploading a World for Hytale, make sure you upload it to the "Worlds" class and upload your file as a ZIP file.
+
+**Once you've uploaded your file, it will be sent for our moderation team to review, and once approved, it will be live for all players on CurseForge!**
+
+## 4. Additional Resources & Guides
+
+You can refer to the following resources for guides on how to create a project page, using the upload API, and creating the best project page:
+
+- How to Pass Moderation Review: https://blog.curseforge.com/how-to-pass-moderation-review-on-curseforge-2/
+- Creating and Submitting a Project: https://support.curseforge.com/en/support/solutions/articles/9000197241-creating-and-submitting-a-project
+- How to Create the Best Project Page: https://blog.curseforge.com/how-to-create-the-best-project-page/
+- Our Mod Approval Process: https://blog.curseforge.com/our-mod-approval-process/
diff --git a/content/docs/sq-AL/publishing/index.mdx b/content/docs/sq-AL/publishing/index.mdx
new file mode 100644
index 00000000..fb60fa35
--- /dev/null
+++ b/content/docs/sq-AL/publishing/index.mdx
@@ -0,0 +1,16 @@
+---
+title: Publishing Your Mod
+description: Learn how to publish your mod to the community.
+---
+
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
+
+We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
+
+- [Publishing on Modtale](./publishing/modtale)
+- [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
+
+<Callout>
+  If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
+</Callout>
diff --git a/content/docs/sq-AL/publishing/modtale.mdx b/content/docs/sq-AL/publishing/modtale.mdx
new file mode 100644
index 00000000..3983a5e4
--- /dev/null
+++ b/content/docs/sq-AL/publishing/modtale.mdx
@@ -0,0 +1,137 @@
+---
+title: Modtale
+description: Complete guide to publishing and managing your Hytale mods on Modtale.
+---
+
+# Publishing Your Mod on Modtale
+
+[Modtale](https://modtale.net) is the Hytale Community Repository for discovering mods, asset packs, worlds, and modpacks.
+
+This guide will walk you through the complete process of publishing your mod.
+
+## Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file of your plugin, or `.zip` of your asset pack
+- A description of your mod's features
+
+We also recommended:
+
+- High-quality screenshots or images of your mod in action
+- A clear logo or icon (recommended size: 512x512px)
+- Any dependencies or requirements documented
+
+## Step-by-Step Publishing Process
+
+### 1. Account Setup
+
+Sign in to [Modtale](https://modtale.net) using your preferred method. If you don't have an account, create one first.
+
+### 2. Start Creating
+
+Click on the **"Create"** button in the navigation bar or go directly to the [upload page](https://modtale.net/upload).
+
+### 3. Choose Content Type
+
+Select the appropriate content type for your submission:
+
+- **Server Plugins** - For Hytale server-side plugins and modifications
+- **Data Assets** - For custom data packs, loot tables, and other data-driven content
+- **Art Assets** - For texture packs, models, and other artistic content
+- **Worlds** - For custom Hytale worlds
+- **Modpacks** - For curated collections of mods and assets
+
+![Content Type Selection](/assets/guides/modtale_type.png)
+
+### 4. Basic Information
+
+Fill in the essential details:
+
+- **Name**: Choose a clear, descriptive name for your mod
+- **Summary**: Write a brief description (1-2 sentences, 250 char max) that explains what your mod does
+
+![Project Title and Description](/assets/guides/modtale_title.png)
+
+### 5. Project Configuration
+
+Now you're on your project's management page. Here you can:
+
+#### Upload Files
+
+Navigate to the **"Files"** tab and upload your `.jar` or `.zip` file:
+
+- Drag and drop your file or use the upload button
+- Add version notes describing changes and new features
+- Mark release type (Release, Beta, Alpha)
+
+![File Upload Interface](/assets/guides/modtale_upload.png)
+
+#### Customize Your Project
+
+- **Logo**: Upload a high-quality logo (512x512 recommended)
+- **Banner**: Upload a banner for your page (1920x640 recommended)
+- **Screenshots**: Add multiple screenshots showing your mod in action
+- **Description**: Write a comprehensive description using Markdown formatting
+- **Links**: Add links to your source code, Discord server, or documentation
+- **Tags**: Add relevant tags to help users find your mod
+- **License**: Indicate what license your mod uses from a selection of common licenses, or use a custom license
+
+## Best Practices
+
+### Documentation
+
+<Callout type="info">
+  Always include comprehensive documentation in your mod description. Users should understand what your mod does, how to use it, and any special requirements.
+</Callout>
+
+### Version Notes
+
+When uploading new versions:
+
+- You must adhere to SemVer
+- Clearly document all changes and new features
+- Include bug fixes and known issues
+- Mention any breaking changes or migration steps
+- List new dependencies or requirement changes
+
+### Visual Appeal
+
+- Use high-quality screenshots that showcase your mod's features in the gallery
+- Create an eye-catching logo that represents your mod
+- Consider adding a banner image for your project page
+
+### Community Engagement
+
+- Respond to comments and feedback promptly
+- Consider creating a Discord server for community support
+- Regularly update your mod based on user feedback
+
+## After Publishing
+
+### Automated updates
+
+- You can configure your project to automatically upload new versions using Github Actions, Gradle, Maven, or Go. See examples [here](https://github.com/Modtale/modtale-example)
+
+### Monitoring Your Project
+
+- Check the analytics to see download statistics
+- Monitor comments and reviews
+- Keep track of bug reports and feature requests
+
+### Marketing Your Mod
+
+- Share your mod on relevant Hytale communities
+- Create showcase videos or tutorials
+- Engage with other modders and creators
+
+<Callout type="warning">
+  Remember to keep your mod updated for new Hytale versions and maintain compatibility with Hytale's modding framework to maximize your audience reach.
+</Callout>
+
+## Getting Help
+
+If you encounter any issues during the publishing process:
+
+- Join their Discord community for support
+- Contact the Modtale team directly through their support channels
diff --git a/content/docs/sq-AL/quick-start.mdx b/content/docs/sq-AL/quick-start.mdx
new file mode 100644
index 00000000..18ab3e2d
--- /dev/null
+++ b/content/docs/sq-AL/quick-start.mdx
@@ -0,0 +1,11 @@
+---
+title: Quick Start
+description: Setting up a standard Hytale project.
+---
+
+Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+
+* [Java Basics](./guides/java-basics/00-introduction)
+* [Setting up your dev environment](./guides/plugin/setting-up-env)
+* [Entity Component System (ECS)](./guides/ecs)
+* [Publishing your mod](./guides/publishing)
diff --git a/content/docs/sq-AL/server/entities.mdx b/content/docs/sq-AL/server/entities.mdx
new file mode 100644
index 00000000..872f3fa4
--- /dev/null
+++ b/content/docs/sq-AL/server/entities.mdx
@@ -0,0 +1,441 @@
+---
+title: Entities
+description: List of all Entities in Hytale
+icon: List
+full: true
+---
+
+This page contains a list of all Entities available to be used as a key in the AssetMap.
+
+- Antelope
+- Archaeopteryx
+- Armadillo
+- Arrow_Crossbow_Signature
+- Arrow_Crude
+- Arrow_Fire
+- Arrow_Frost
+- Arrow_Iron
+- Arrow_Ricochet
+- Arrow_Ricochet_Signature
+- Arrow_Shortbow_Signature
+- Arrow_Vamp
+- Arrow_Vamp_Signature
+- Axe_Bone
+- Axe_Stone_Trork
+- Bat
+- Bat_Ice
+- Bear_Grizzly
+- Bear_Polar
+- Bison
+- Bison_Calf
+- Bluebird
+- Bluegill
+- Boar
+- Boar_Piglet
+- Boat
+- Bomb
+- Bomb_Fire_Goblin
+- Bomb_Fire_Goblin_Dud
+- Bomb_Large_Fire_Goblin
+- Bomb_Popberry
+- Bomb_Potion_Poison
+- Boy_Trail
+- Bramblekin
+- Bramblekin_Shaman
+- Bullet_Blunderbuss
+- Bunny
+- Cactee
+- Cactee_Spike
+- Calf
+- Camel
+- Camel_Calf
+- Cat
+- Catfish
+- Chick
+- Chick_Desert
+- Chicken
+- Chicken_Desert
+- Chicken_Undead
+- Clownfish
+- Corgi
+- Cow
+- Cow_Undead
+- Crab
+- Crawler_Void
+- Crocodile
+- Crossbow_Turret
+- Crossbow_Turret_Item_Projectile
+- Crow
+- Dagger_Adamantite
+- Dagger_Bone
+- Dagger_Bronze
+- Dagger_Bronze_Ancient
+- Dagger_Cobalt
+- Dagger_Copper
+- Dagger_Crude
+- Dagger_Doomed
+- Dagger_Fang_Doomed
+- Dagger_Iron
+- Dagger_Mithril
+- Dagger_Onyxium
+- Dagger_Stone_Trork
+- Dagger_Thorium
+- Debug
+- Deer_Doe
+- Deployable_Fire_Trap
+- Deployable_Fire_Trap_Preview
+- Dog
+- Dragon_Fire
+- Dragon_Frost
+- Dragon_Void
+- Duck
+- Eel_Moray
+- Egg
+- Emberwulf
+- Eye_Void
+- Eye_Void_Blast
+- Fen_Stalker
+- Feran
+- Feran_Burrower
+- Feran_Civilian
+- Feran_Cub
+- Feran_Longtooth
+- Feran_Sharptooth
+- Feran_Windwalker
+- Feran_Windwalker_Wind_Burst
+- Feran_Windwalker_Wind_Vortex
+- Finch_Green
+- Fireball
+- Flamingo
+- Fox
+- Frog_Blue
+- Frog_Green
+- Frog_Orange
+- Frostgill
+- Gecko
+- Ghoul
+- Goat
+- Goat_Kid
+- Goblin
+- Goblin_Boss
+- Goblin_Duke
+- Goblin_Duke_Large
+- Goblin_Hermit
+- Goblin_Lobber
+- Goblin_Miner
+- Goblin_Ogre
+- Goblin_Scrapper
+- Goblin_Thief
+- Golem_Crystal_Earth
+- Golem_Crystal_Flame
+- Golem_Crystal_Frost
+- Golem_Crystal_Sand
+- Golem_Crystal_Thunder
+- Golem_Firesteel
+- Golem_Guardian_Void
+- Grooble
+- Hatworm
+- Hawk
+- Healing_Totem
+- Healing_Totem_Projectile
+- Hedera
+- Horse
+- Horse_Foal
+- Horse_Skeleton
+- Horse_Skeleton_Armored
+- Hound_Bleached
+- Hyena
+- Ice_Ball
+- Ice_Bolt
+- Ingredient_Poop
+- Jellyfish_Blue
+- Jellyfish_Cyan
+- Jellyfish_Green
+- Jellyfish_Man_Of_War
+- Jellyfish_Red
+- Jellyfish_Yellow
+- Klops
+- Klops_Gentleman
+- Klops_Merchant
+- Klops_Miner
+- Kunai
+- Kweebec_Rootling
+- Kweebec_Sapling
+- Kweebec_Sapling_Brown
+- Kweebec_Sapling_Christmas_Blue
+- Kweebec_Sapling_Christmas_Green
+- Kweebec_Sapling_Christmas_Pink
+- Kweebec_Sapling_Green
+- Kweebec_Sapling_HardHat
+- Kweebec_Sapling_Orange
+- Kweebec_Sapling_Pink
+- Kweebec_Sapling_Razorleaf
+- Kweebec_Sapling_Red
+- Kweebec_Sapling_Treesinger
+- Kweebec_Sapling_Yellow
+- Kweebec_Seedling
+- Kweebec_Sproutling
+- Kweebec_Sproutling_Blue
+- Kweebec_Sproutling_Lime
+- Lamb
+- Larva_Silk
+- Larva_Void
+- Leopard_Snow
+- Lizard_Sand
+- Lobster
+- Mannequin
+- Meerkat
+- Minecart
+- Minnow
+- Model_Bee_Swarm
+- Model_Deer_Stag
+- Molerat
+- Moose_Bull
+- Moose_Cow
+- Mosshorn
+- Mosshorn_Plain
+- Mouflon
+- Mouflon_Lamb
+- Mouse
+- Mushee
+- NPC_Elf
+- NPC_Path_Marker
+- NPC_Santa
+- NPC_Sound_Shoe
+- NPC_Spawn_Marker
+- Necromancer_Void
+- Objective_Location_Marker
+- Outlander
+- Outlander_Berserker
+- Outlander_Brute
+- Outlander_Cultist
+- Outlander_Hunter
+- Outlander_Marauder
+- Outlander_Peon
+- Outlander_Priest
+- Outlander_Sorcerer
+- Outlander_Stalker
+- Owl_Brown
+- Owl_Snow
+- Parrot
+- Penguin
+- Pig
+- Pig_Undead
+- Pig_Wild
+- Pigeon
+- Piglet
+- Piglet_Wild
+- Pike
+- Piranha
+- Piranha_Black
+- Player
+- PlayerTestModel_G
+- PlayerTestModel_V
+- Projectile
+- Pterodactyl
+- Pufferfish
+- Rabbit
+- Ram
+- Ram_Lamb
+- Raptor_Cave
+- Rat
+- Raven
+- Reindeer_Christmas
+- Rex_Cave
+- Rubble_Aqua
+- Rubble_Basalt
+- Rubble_Calcite
+- Rubble_Default
+- Rubble_Ice
+- Rubble_Marble
+- Rubble_Quartzite
+- Rubble_Sandstone
+- Rubble_Sandstone_Red
+- Rubble_Sandstone_White
+- Rubble_Shale
+- Rubble_Slate
+- Rubble_Stone
+- Rubble_Stone_Mossy
+- Rubble_Volcanic
+- Salmon
+- Saurian
+- Saurian_Hunter
+- Saurian_Rogue
+- Saurian_Warrior
+- Scarak_Broodmother
+- Scarak_Broodmother_Young
+- Scarak_Defender
+- Scarak_Fighter
+- Scarak_Fighter_Royal_Guard
+- Scarak_Louse
+- Scarak_Seeker
+- Scarak_Seeker_Spitball
+- Scorpion
+- Shadow_Knight
+- Shark_Hammerhead
+- Sheep
+- Shellfish_Lava
+- Showcase_Cobalt_Gear
+- Showcase_Copper_Gear
+- Showcase_Iron_Gear
+- Showcase_Iron_TargetDummy_1
+- Showcase_Mannequin_Heal
+- Showcase_Mannequin_Inv_Portal
+- Showcase_Mannequin_Inv_Sphere
+- Showcase_Mannequin_Lightning
+- Showcase_Mannequin_Sitting
+- Showcase_Onyxium_Gear
+- Showcase_Prisma_Gear
+- Showcase_Skeleton_Assasin
+- Showcase_Skeleton_Dead
+- Showcase_Skeleton_Guard
+- Showcase_Skeleton_Tank
+- Showcase_Wooden_Gear
+- Skeleton
+- Skeleton_Archer
+- Skeleton_Archmage
+- Skeleton_Burnt_Alchemist
+- Skeleton_Burnt_Archer
+- Skeleton_Burnt_Gunner
+- Skeleton_Burnt_Knight
+- Skeleton_Burnt_Lancer
+- Skeleton_Burnt_Praetorian
+- Skeleton_Burnt_Soldier
+- Skeleton_Burnt_Wizard
+- Skeleton_Fighter
+- Skeleton_Frost_Archer
+- Skeleton_Frost_Archmage
+- Skeleton_Frost_Fighter
+- Skeleton_Frost_Knight
+- Skeleton_Frost_Mage
+- Skeleton_Frost_Ranger
+- Skeleton_Frost_Scout
+- Skeleton_Frost_Soldier
+- Skeleton_Incandescent_Fighter
+- Skeleton_Incandescent_Footman
+- Skeleton_Incandescent_Head
+- Skeleton_Incandescent_Mage
+- Skeleton_Knight
+- Skeleton_Mage
+- Skeleton_Mage_Corruption_Orb
+- Skeleton_Pirate_Captain
+- Skeleton_Pirate_Gunner
+- Skeleton_Pirate_Striker
+- Skeleton_Ranger
+- Skeleton_Sand_Archer
+- Skeleton_Sand_Archmage
+- Skeleton_Sand_Assassin
+- Skeleton_Sand_Guard
+- Skeleton_Sand_Mage
+- Skeleton_Sand_Ranger
+- Skeleton_Sand_Scout
+- Skeleton_Sand_Soldier
+- Skeleton_Scout
+- Skeleton_Soldier
+- Skrill
+- Skrill_Chick
+- Slothian
+- Slothian_Elder
+- Slothian_Kid
+- Slothian_Monk
+- Slothian_Scout
+- Slothian_Villager
+- Slothian_Warrior
+- Slowness_Totem
+- Slowness_Totem_Projectile
+- Slug_Magma
+- Snail_Frost
+- Snail_Magma
+- Snake_Cobra
+- Snake_Marsh
+- Snake_Rattle
+- Snapdragon
+- Snapjaw
+- Spark_Living
+- Sparrow
+- Spawn_Void
+- Spear_Adamantite
+- Spear_Adamantite_Saurian
+- Spear_Bone
+- Spear_Bronze
+- Spear_Cobalt
+- Spear_Copper
+- Spear_Crude
+- Spear_Double_Incandescent
+- Spear_Iron
+- Spear_Leaf
+- Spear_Mithril
+- Spear_Onyxium
+- Spear_Scrap
+- Spear_Stone_Trork
+- Spear_Thorium
+- Spear_Tribal
+- Spectre_Void
+- Spider
+- Spider_Cave
+- Spirit_Ember
+- Spirit_Frost
+- Spirit_Root
+- Spirit_Thunder
+- Squirrel
+- Swarm_Bees
+- Sword_Charged_Test
+- Tang_Blue
+- Tang_Chevron
+- Tang_Lemon_Peel
+- Tang_Sailfin
+- Tank
+- Temple_Mithril_Guard
+- Test_Platform
+- Tetrabird
+- Tiger_Sabertooth
+- Toad_Rhino
+- Toad_Rhino_Magma
+- Tornado
+- Tortoise
+- Trash
+- Trillodon
+- Trilobite
+- Trilobite_Black
+- Trork
+- Trork_Brawler
+- Trork_Chieftain
+- Trork_Christmas
+- Trork_Doctor_Witch
+- Trork_Guard
+- Trork_Hunter
+- Trork_Mauler
+- Trork_Sentry
+- Trork_Shaman
+- Trork_Warrior
+- Trout_Rainbow
+- Tuluk
+- Tuluk_Fisherman
+- Turkey
+- Turkey_Chick
+- Vulture
+- Warp
+- Warrior_Quest
+- Warthog
+- Warthog_Piglet
+- Werewolf
+- Whale_Humpback
+- Wolf_Black
+- Wolf_Outlander_Priest
+- Wolf_Outlander_Sorcerer
+- Wolf_Trork_Hunter
+- Wolf_Trork_Shaman
+- Wolf_White
+- Woodpecker
+- Wraith
+- Wraith_Lantern
+- Wurmling_Frost
+- Yeti
+- Zombie
+- Zombie_Aberrant
+- Zombie_Aberrant_Big
+- Zombie_Aberrant_Small
+- Zombie_Burnt
+- Zombie_Frost
+- Zombie_Sand
+- Zombie_Werewolf
diff --git a/content/docs/sq-AL/server/events.mdx b/content/docs/sq-AL/server/events.mdx
new file mode 100644
index 00000000..ca7ed28f
--- /dev/null
+++ b/content/docs/sq-AL/server/events.mdx
@@ -0,0 +1,104 @@
+---
+title: Events
+description: List of all events in Hytale
+icon: List
+full: true
+---
+
+## IEvent
+
+- AddPlayerToWorldEvent
+- AllNPCsLoadedEvent
+- AllWorldsLoadedEvent
+- AssetMonitorEvent
+  - AssetStoreMonitorEvent
+  - CommonAssetMonitorEvent
+- AssetPackRegisterEvent
+- AssetPackUnregisterEvent
+- AssetStoreEvent
+  - RegisterAssetStoreEvent
+  - RemoveAssetStoreEvent
+- AssetsEvent
+  - GenerateAssetsEvent
+  - LoadedAssetsEvent
+  - RemovedAssetsEvent
+- BootEvent
+- ChunkEvent
+  - ChunkPreLoadProcessEvent
+- DrainPlayerFromWorldEvent
+- EditorClientEvent
+  - AssetEditorActivateButtonEvent
+  - AssetEditorAssetCreatedEvent
+  - AssetEditorClientDisconnectEvent
+  - AssetEditorSelectAssetEvent
+  - AssetEditorUpdateWeatherPreviewLockEvent
+- EntityEvent
+  - EntityRemoveEvent
+  - LivingEntityInventoryChangeEvent
+- GenerateDefaultLanguageEvent
+- GenerateSchemaEvent
+- GenerateServerStateEvent
+- ItemContainerChangeEvent
+- ~~LivingEntityUseBlockEvent~~ DEPRECATED
+- LoadAssetEvent
+- LoadedNPCEvent
+- MessagesUpdated
+- PlayerConnectEvent
+- PlayerEvent
+  - ~~PlayerCraftEvent~~ DEPRECATED
+  - ~~PlayerInteractEvent~~ DEPRECATED
+  - PlayerMouseButtonEvent
+  - PlayerMouseMotionEvent
+  - PlayerReadyEvent
+  - RemovePlayerFromWorldEvent
+- PlayerRefEvent
+  - PlayerDisconnectEvent
+- PlayerSetupConnectEvent
+- PlayerSetupDisconnectEvent
+- PluginEvent
+  - PluginSetupEvent
+- ~~PrepareUniverseEvent~~ DEPRECATED
+- ShutdownEvent
+- SingleplayerRequestAccessEvent
+- TreasureChestOpeningEvent
+- WindowCloseEvent
+- WorldEvent
+  - AddWorldEvent
+  - RemoveWorldEvent
+  - StartWorldEvent
+- WorldPathChangedEvent
+
+## IAsyncEvent
+
+- AssetEditorFetchAutoCompleteDataEvent
+- AssetEditorRequestDataSetEvent
+- PlayerChatEvent
+- SendCommonAssetsEvent
+
+## EcsEvent
+
+- CancellableEcsEvent
+  - BreakBlockEvent
+  - ChangeGameModeEvent
+  - ChunkSaveEvent
+  - ChunkUnloadEvent
+  - CraftRecipeEvent
+    - Post
+    - Pre
+  - Damage
+  - DamageBlockEvent
+  - DropItemEvent
+    - Drop
+    - PlayerRequest
+  - InteractivelyPickupItemEvent
+  - PlaceBlockEvent
+  - PrefabPasteEvent
+  - SwitchActiveSlotEvent
+- DiscoverInstanceEvent
+  - Display
+- DiscoverZoneEvent
+  - Display
+- MoonPhaseChangeEvent
+- UseBlockEvent
+  - Post
+  - Pre
diff --git a/content/docs/sq-AL/server/sounds.mdx b/content/docs/sq-AL/server/sounds.mdx
new file mode 100644
index 00000000..5b54a035
--- /dev/null
+++ b/content/docs/sq-AL/server/sounds.mdx
@@ -0,0 +1,1162 @@
+---
+title: Sounds
+description: List of all Sounds in Hytale
+icon: List
+full: true
+---
+
+This page contains a list of all Sounds available to be used as a key in the AssetMap.
+
+- SFX_Alchemy_Bench_Close
+- SFX_Alchemy_Bench_Craft
+- SFX_Alchemy_Bench_Open
+- SFX_Antelope_Alerted
+- SFX_Antelope_Death
+- SFX_Antelope_Hurt
+- SFX_Antelope_Run
+- SFX_Antelope_Walk
+- SFX_Arcane_Workbench_Close_Local
+- SFX_Arcane_Workbench_Craft
+- SFX_Arcane_Workbench_Open_Local
+- SFX_Armour_Bench_Close
+- SFX_Armour_Bench_Craft
+- SFX_Armour_Bench_Open
+- SFX_Arrow_Fire_Hit
+- SFX_Arrow_Fire_Miss
+- SFX_Arrow_Frost_Hit
+- SFX_Arrow_Frost_Miss
+- SFX_Arrow_FullCharge_Hit
+- SFX_Arrow_FullCharge_Miss
+- SFX_Arrow_HalfCharge_Hit
+- SFX_Arrow_HalfCharge_Miss
+- SFX_Arrow_NoCharge_Hit
+- SFX_Arrow_NoCharge_Miss
+- SFX_Arrow_Whistle
+- SFX_Attn_Loud
+- SFX_Attn_Moderate
+- SFX_Attn_Quiet
+- SFX_Attn_VeryLoud
+- SFX_Attn_VeryQuiet
+- SFX_Avatar_Powers_Disable
+- SFX_Avatar_Powers_Disable_Local
+- SFX_Avatar_Powers_Enable
+- SFX_Avatar_Powers_Enable_Local
+- SFX_Axe_Crude_Impact
+- SFX_Axe_Crude_Swing
+- SFX_Axe_Iron_Impact
+- SFX_Axe_Iron_Swing
+- SFX_Axe_Special_Impact
+- SFX_Axe_Special_Swing
+- SFX_Axe_Stone_Trork_Hit
+- SFX_Axe_Stone_Trork_Miss
+- SFX_Bat_Alerted
+- SFX_Bat_Death
+- SFX_Bat_Hurt
+- SFX_Battleaxe_T1_Block_Impact
+- SFX_Battleaxe_T1_Impact
+- SFX_Battleaxe_T1_Launch
+- SFX_Battleaxe_T1_Launch_Local
+- SFX_Battleaxe_T1_Raise
+- SFX_Battleaxe_T1_Raise_Local
+- SFX_Battleaxe_T1_Shove
+- SFX_Battleaxe_T1_Shove_Local
+- SFX_Battleaxe_T1_Swing
+- SFX_Battleaxe_T1_Swing_Charged
+- SFX_Battleaxe_T1_Swing_Charged_Local
+- SFX_Battleaxe_T1_Swing_Down_Local
+- SFX_Battleaxe_T1_Swing_LR_Local
+- SFX_Battleaxe_T1_Swing_RL_Local
+- SFX_Battleaxe_T2_Impact
+- SFX_Battleaxe_T2_Raise
+- SFX_Battleaxe_T2_Raise_Local
+- SFX_Battleaxe_T2_Signature_End
+- SFX_Battleaxe_T2_Signature_End_Local
+- SFX_Battleaxe_T2_Signature_Swing
+- SFX_Battleaxe_T2_Signature_Swing_Local
+- SFX_Battleaxe_T2_Swing
+- SFX_Battleaxe_T2_Swing_Charged
+- SFX_Battleaxe_T2_Swing_Charged_Local
+- SFX_Battleaxe_T2_Swing_Down_Local
+- SFX_Battleaxe_T2_Swing_LR_Local
+- SFX_Battleaxe_T2_Swing_RL_Local
+- SFX_Bear_Grizzly_Alerted
+- SFX_Bear_Grizzly_Attack
+- SFX_Bear_Grizzly_Death
+- SFX_Bear_Grizzly_Hurt
+- SFX_Bear_Grizzly_Run
+- SFX_Bear_Grizzly_Sleep
+- SFX_Bear_Walk
+- SFX_Bench_Placeholder
+- SFX_Bison_Alerted
+- SFX_Bison_Death
+- SFX_Bison_Hurt
+- SFX_Bison_Idle
+- SFX_Bison_Run
+- SFX_Bison_Walk
+- SFX_Blunderbuss_Bullet_WhizBy
+- SFX_Blunderbuss_Fire
+- SFX_Blunderbuss_Fire_Local
+- SFX_Blunderbuss_Hit
+- SFX_Blunderbuss_Load
+- SFX_Blunderbuss_Load_Local
+- SFX_Blunderbuss_Miss
+- SFX_Blunderbuss_No_Ammo
+- SFX_Boar_Alerted
+- SFX_Boar_Death
+- SFX_Boar_Hurt
+- SFX_Boar_Run
+- SFX_Boar_Sleep
+- SFX_Boar_Walk
+- SFX_Bomb_Fire_Goblin_Bounce
+- SFX_Bomb_Fire_Goblin_Death
+- SFX_Bomb_Fire_Goblin_Hit
+- SFX_Bomb_Fire_Goblin_Miss
+- SFX_Bomb_Fuse
+- SFX_Bone_Break
+- SFX_Bone_Build
+- SFX_Bone_Hit
+- SFX_Bone_Land
+- SFX_Bone_Walk
+- SFX_Bow_No_Ammo
+- SFX_Bow_T1_Block_Impact
+- SFX_Bow_T1_Draw
+- SFX_Bow_T1_Draw_Local
+- SFX_Bow_T1_Raise
+- SFX_Bow_T1_Raise_Local
+- SFX_Bow_T1_Shoot
+- SFX_Bow_T1_Shoot_Local
+- SFX_Bow_T1_Swing
+- SFX_Bow_T1_Swing_Local
+- SFX_Bow_T2_Draw
+- SFX_Bow_T2_Draw_Local
+- SFX_Bow_T2_Shoot
+- SFX_Bow_T2_Shoot_Local
+- SFX_Bow_T2_Signature_Loop
+- SFX_Bow_T2_Signature_Loop_Local
+- SFX_Bow_T2_Signature_Nock
+- SFX_Bow_T2_Signature_Nock_Local
+- SFX_Bow_T2_Signature_Shoot
+- SFX_Bow_T2_Signature_Shoot_Local
+- SFX_Bramble_MoveIn
+- SFX_Branch_Break
+- SFX_Branch_Build
+- SFX_Branch_Hit
+- SFX_Branch_Land
+- SFX_Branch_Walk
+- SFX_Brazier_Break
+- SFX_Brazier_Build
+- SFX_Bunny_Alerted
+- SFX_Bunny_Death
+- SFX_Bunny_Hurt
+- SFX_Bush_Break
+- SFX_Bush_Hit
+- SFX_Bush_MoveIn
+- SFX_Cactus_Break
+- SFX_Cactus_Hit
+- SFX_Cactus_Large_Hit
+- SFX_Cactus_Small_Break
+- SFX_Cactus_Small_Hit
+- SFX_Calf_Hurt
+- SFX_Calf_Run
+- SFX_Calf_Walk
+- SFX_Camel_Alerted
+- SFX_Camel_Death
+- SFX_Camel_Hurt
+- SFX_Camel_Laydown
+- SFX_Camel_Run
+- SFX_Camel_Sleep
+- SFX_Camel_Wake
+- SFX_Camel_Walk
+- SFX_Campfire_Break
+- SFX_Campfire_Build
+- SFX_Campfire_Close_Local
+- SFX_Campfire_Default_Loop
+- SFX_Campfire_Open_Local
+- SFX_Campfire_Processing
+- SFX_Campfire_Processing_End
+- SFX_Campfire_Processing_Failed
+- SFX_Candle_Default_Loop
+- SFX_Candle_Off
+- SFX_Capture_Crate_Capture_Fail_Local
+- SFX_Capture_Crate_Capture_Succeed
+- SFX_Capture_Crate_Capture_Succeed_Local
+- SFX_Capture_Crate_Spawn_Fail_Local
+- SFX_Capture_Crate_Spawn_Succeed
+- SFX_Cauldron_Bubbling
+- SFX_Cauldron_Bubbling_Small
+- SFX_Chest_Legendary_Close_Player
+- SFX_Chest_Legendary_FirstOpen_Player
+- SFX_Chest_Legendary_Loop
+- SFX_Chest_Legendary_Open
+- SFX_Chest_Wooden_Close
+- SFX_Chest_Wooden_Open
+- SFX_Chest_Wooden_Open_Player
+- SFX_Chick_Alerted
+- SFX_Chick_Death
+- SFX_Chick_Hurt
+- SFX_Chicken_Alerted
+- SFX_Chicken_Death
+- SFX_Chicken_Flee
+- SFX_Chicken_Hurt
+- SFX_Chicken_Run
+- SFX_Chicken_Walk
+- SFX_Clay_Pot_Large_Break
+- SFX_Clay_Pot_Large_Build
+- SFX_Clay_Pot_Large_Hit
+- SFX_Clay_Pot_Large_Walk
+- SFX_Clay_Pot_Small_Break
+- SFX_Clay_Pot_Small_Build
+- SFX_Clay_Pot_Small_Hit
+- SFX_Clay_Pot_Small_Walk
+- SFX_Cloth_Break
+- SFX_Cloth_Build
+- SFX_Cloth_Hit
+- SFX_Cloth_Land
+- SFX_Cloth_Walk
+- SFX_Club_Meat_Impact
+- SFX_Club_Meat_Swing
+- SFX_Club_Special_Impact
+- SFX_Club_Special_Swing
+- SFX_Club_Steel_Impact
+- SFX_Club_Steel_Swing
+- SFX_Club_Wood_Impact
+- SFX_Club_Wood_Swing
+- SFX_Cocoon_Active
+- SFX_Cocoon_Break
+- SFX_Cocoon_Build
+- SFX_Cocoon_Hit
+- SFX_Cocoon_Walk
+- SFX_Coins_Land
+- SFX_Coins_Walk
+- SFX_Consume_Bread
+- SFX_Consume_Bread_Local
+- SFX_Cow_Alerted
+- SFX_Cow_Death
+- SFX_Cow_Hurt
+- SFX_Cow_Idle
+- SFX_Cow_Run
+- SFX_Cow_Sleep
+- SFX_Cow_Walk
+- SFX_Crawler_Void_Alerted
+- SFX_Crawler_Void_Alerted_02
+- SFX_Crawler_Void_Death
+- SFX_Crawler_Void_Despawn
+- SFX_Crawler_Void_Hurt
+- SFX_Crawler_Void_Run
+- SFX_Crawler_Void_Sleep
+- SFX_Crawler_Void_Spawn
+- SFX_Crawler_Void_Spawn_02
+- SFX_Crawler_Void_Walk
+- SFX_Creative_Play_Add_Mask
+- SFX_Creative_Play_Brush_Erase
+- SFX_Creative_Play_Brush_Mode
+- SFX_Creative_Play_Brush_Paint_Base
+- SFX_Creative_Play_Brush_Paint_Idle_Layer
+- SFX_Creative_Play_Brush_Paint_Move_Layer
+- SFX_Creative_Play_Brush_Shape
+- SFX_Creative_Play_Brush_Stamp
+- SFX_Creative_Play_Error
+- SFX_Creative_Play_Eyedropper_Select
+- SFX_Creative_Play_Paste
+- SFX_Creative_Play_Selection_Drag
+- SFX_Creative_Play_Selection_Place
+- SFX_Creative_Play_Selection_Scale
+- SFX_Creative_Play_Selection_Widget
+- SFX_Creative_Play_Set_Mask
+- SFX_Crocodile_Alerted
+- SFX_Crocodile_Death
+- SFX_Crocodile_Hurt
+- SFX_Crops_Grow
+- SFX_Crops_Grow_Stage_Complete
+- SFX_Crow_Death
+- SFX_Crow_Hurt
+- SFX_Crystal_Break
+- SFX_Crystal_Build
+- SFX_Crystal_Hit
+- SFX_Crystal_Walk
+- SFX_Daggers_T1_Guard
+- SFX_Daggers_T1_Guard_Local
+- SFX_Daggers_T1_Pounce
+- SFX_Daggers_T1_Pounce_Local
+- SFX_Daggers_T1_Slash_Impact
+- SFX_Daggers_T1_Stab_Double_Impact
+- SFX_Daggers_T1_Stab_Impact
+- SFX_Daggers_T1_Stab_Left_Local
+- SFX_Daggers_T1_Stab_Retreat
+- SFX_Daggers_T1_Stab_Retreat_Local
+- SFX_Daggers_T1_Stab_Right_Local
+- SFX_Daggers_T1_Swing
+- SFX_Daggers_T1_Swing_Double
+- SFX_Daggers_T1_Swing_Double_Local
+- SFX_Daggers_T1_Swing_LR_Local
+- SFX_Daggers_T1_Swing_RL_Local
+- SFX_Daggers_T2_Guard
+- SFX_Daggers_T2_Guard_Local
+- SFX_Daggers_T2_Signature_P1
+- SFX_Daggers_T2_Signature_P1_Local
+- SFX_Daggers_T2_Signature_P2
+- SFX_Daggers_T2_Signature_P2_Local
+- SFX_Daggers_T2_Signature_P3
+- SFX_Daggers_T2_Signature_P3_Local
+- SFX_Daggers_T2_Slash_Impact
+- SFX_Daggers_T2_Stab_Double_Impact
+- SFX_Daggers_T2_Stab_Impact
+- SFX_Daggers_T2_Stab_Left_Local
+- SFX_Daggers_T2_Stab_Retreat
+- SFX_Daggers_T2_Stab_Retreat_Local
+- SFX_Daggers_T2_Stab_Right_Local
+- SFX_Daggers_T2_Swing
+- SFX_Daggers_T2_Swing_Double
+- SFX_Daggers_T2_Swing_Double_Local
+- SFX_Daggers_T2_Swing_LR_Local
+- SFX_Daggers_T2_Swing_RL_Local
+- SFX_Deer_Doe_Alerted
+- SFX_Deer_Doe_Death
+- SFX_Deer_Doe_Hurt
+- SFX_Deer_Doe_Run
+- SFX_Deer_Doe_Sleep
+- SFX_Deer_Stag_Alerted
+- SFX_Deer_Stag_Death
+- SFX_Deer_Stag_Hurt
+- SFX_Deer_Stag_Roar
+- SFX_Deer_Stag_Run
+- SFX_Deer_Stag_Sleep
+- SFX_Deer_Walk
+- SFX_Default_Break
+- SFX_Default_Build
+- SFX_Default_Clone
+- SFX_Default_Harvest
+- SFX_Default_Walk
+- SFX_Deployable_Totem_Heal_Despawn
+- SFX_Deployable_Totem_Heal_Effect_Local
+- SFX_Deployable_Totem_Heal_Spawn
+- SFX_Deployable_Totem_Slowing_Despawn
+- SFX_Deployable_Totem_Slowing_Effect_Local
+- SFX_Deployable_Totem_Slowing_Spawn
+- SFX_Dirt_Break
+- SFX_Dirt_Build
+- SFX_Dirt_Clone
+- SFX_Dirt_Hit
+- SFX_Dirt_Land
+- SFX_Dirt_Walk
+- SFX_Discovery_Z1_Medium
+- SFX_Discovery_Z1_Short
+- SFX_Discovery_Z2_Medium
+- SFX_Discovery_Z2_Short
+- SFX_Discovery_Z3_Medium
+- SFX_Discovery_Z3_Short
+- SFX_Discovery_Z4_Medium
+- SFX_Discovery_Z4_Short
+- SFX_Divine_Respawn
+- SFX_Door_Ancient_Close
+- SFX_Door_Ancient_Open
+- SFX_Door_Crude_Close
+- SFX_Door_Crude_Open
+- SFX_Door_Desert_Close
+- SFX_Door_Desert_Open
+- SFX_Door_Jungle_Close
+- SFX_Door_Jungle_Open
+- SFX_Door_Lumberjack_Close
+- SFX_Door_Lumberjack_Open
+- SFX_Door_Temple_Dark_Close
+- SFX_Door_Temple_Dark_Open
+- SFX_Door_Temple_Light_Close
+- SFX_Door_Temple_Light_Open
+- SFX_Door_Wooden_Close
+- SFX_Door_Wooden_Open
+- SFX_Drag_Armor_Cloth
+- SFX_Drag_Armor_Heavy
+- SFX_Drag_Armor_Leather
+- SFX_Drag_Blocks_Gravel
+- SFX_Drag_Blocks_Soft
+- SFX_Drag_Blocks_Splatty
+- SFX_Drag_Blocks_Stone
+- SFX_Drag_Blocks_Wood
+- SFX_Drag_Item_Default
+- SFX_Drag_Items_Bones
+- SFX_Drag_Items_Chest
+- SFX_Drag_Items_Clay
+- SFX_Drag_Items_Cloth
+- SFX_Drag_Items_Foliage
+- SFX_Drag_Items_Gadget
+- SFX_Drag_Items_Gems
+- SFX_Drag_Items_Ingots
+- SFX_Drag_Items_Leather
+- SFX_Drag_Items_Metal
+- SFX_Drag_Items_Paper
+- SFX_Drag_Items_Potion
+- SFX_Drag_Items_Seeds
+- SFX_Drag_Items_Shells
+- SFX_Drag_Items_Splatty
+- SFX_Drag_Weapon_Blade_Small
+- SFX_Drag_Weapon_Blunt_Large
+- SFX_Drag_Weapons_Arrows
+- SFX_Drag_Weapons_Blade_Large
+- SFX_Drag_Weapons_Blunt_Small
+- SFX_Drag_Weapons_Books
+- SFX_Drag_Weapons_Shield_Metal
+- SFX_Drag_Weapons_Shield_Wood
+- SFX_Drag_Weapons_Stone_Large
+- SFX_Drag_Weapons_Stone_Small
+- SFX_Drag_Weapons_Wand
+- SFX_Drag_Weapons_Wood
+- SFX_Dragon_Sleep
+- SFX_Drop_Armor_Cloth
+- SFX_Drop_Armor_Heavy
+- SFX_Drop_Armor_Leather
+- SFX_Drop_Blocks_Gravel
+- SFX_Drop_Blocks_Soft
+- SFX_Drop_Blocks_Splatty
+- SFX_Drop_Blocks_Stone
+- SFX_Drop_Blocks_Wood
+- SFX_Drop_Item_Default
+- SFX_Drop_Items_Bones
+- SFX_Drop_Items_Chest
+- SFX_Drop_Items_Clay
+- SFX_Drop_Items_Cloth
+- SFX_Drop_Items_Foliage
+- SFX_Drop_Items_Gadget
+- SFX_Drop_Items_Gems
+- SFX_Drop_Items_Ingots
+- SFX_Drop_Items_Leather
+- SFX_Drop_Items_Metal
+- SFX_Drop_Items_Paper
+- SFX_Drop_Items_Potion
+- SFX_Drop_Items_Seeds
+- SFX_Drop_Items_Shells
+- SFX_Drop_Items_Splatty
+- SFX_Drop_Weapon_Blade_Small
+- SFX_Drop_Weapon_Blunt_Large
+- SFX_Drop_Weapons_Arrows
+- SFX_Drop_Weapons_Blade_Large
+- SFX_Drop_Weapons_Blunt_Small
+- SFX_Drop_Weapons_Books
+- SFX_Drop_Weapons_Shield_Metal
+- SFX_Drop_Weapons_Shield_Wood
+- SFX_Drop_Weapons_Stone_Large
+- SFX_Drop_Weapons_Stone_Small
+- SFX_Drop_Weapons_Wand
+- SFX_Drop_Weapons_Wood
+- SFX_Duck_Alerted
+- SFX_Duck_Death
+- SFX_Duck_Hurt
+- SFX_Duck_Run
+- SFX_Effect_Burn_Local
+- SFX_Effect_Burn_World
+- SFX_Effect_Poison_Local
+- SFX_Effect_Poison_World
+- SFX_Egg_Hit
+- SFX_Egg_Miss
+- SFX_Eggsac_Active
+- SFX_Emberwulf_Alerted
+- SFX_Emberwulf_Attack_Bite
+- SFX_Emberwulf_Death
+- SFX_Emberwulf_Hurt
+- SFX_Emberwulf_Run
+- SFX_Emberwulf_Sleep
+- SFX_Emberwulf_Walk
+- SFX_Emit_Forgotten_Whispers
+- SFX_Emit_Lake_Water
+- SFX_Emit_Temple_Wisps
+- SFX_Emit_Tree_Creak
+- SFX_Emit_Wind_Grass
+- SFX_Emit_Wind_Gusts
+- SFX_Env_Emit_Fluid_Lava
+- SFX_Env_Emit_Fluid_Water
+- SFX_Env_Emit_Fluid_Water_Far
+- SFX_Env_Emit_Geyzer
+- SFX_Eye_Void_Alerted
+- SFX_Eye_Void_Attack_Blast
+- SFX_Eye_Void_Attack_Summon
+- SFX_Eye_Void_Death
+- SFX_Eye_Void_Fly_Movement
+- SFX_Eye_Void_Hurt
+- SFX_Eye_Void_Idle
+- SFX_Fen_Stalker_Alerted
+- SFX_Fen_Stalker_Attack_Swing
+- SFX_Fen_Stalker_Attack_Swipe
+- SFX_Fen_Stalker_Death
+- SFX_Fen_Stalker_Eat
+- SFX_Fen_Stalker_Eat_Finish
+- SFX_Fen_Stalker_Greet
+- SFX_Fen_Stalker_Hurt
+- SFX_Fen_Stalker_Run
+- SFX_Fen_Stalker_Scared
+- SFX_Fen_Stalker_Seek
+- SFX_Fen_Stalker_Sniff
+- SFX_Feran_Death
+- SFX_Fern_Break
+- SFX_Fern_MoveIn
+- SFX_Fireball_Bounce
+- SFX_Fireball_Death
+- SFX_Fireball_Miss
+- SFX_Fish_Death
+- SFX_Fish_Flee
+- SFX_Fish_Hurt
+- SFX_Flail_Charge
+- SFX_Flail_Charge_Local
+- SFX_Flail_Swing
+- SFX_Flail_Swing_Left_Local
+- SFX_Flail_Swing_Right_Local
+- SFX_Flame_Break
+- SFX_Flame_Build
+- SFX_Flame_Default_Loop
+- SFX_Flamingo_Alerted
+- SFX_Flamingo_Death
+- SFX_Flamingo_Fly
+- SFX_Flamingo_Hurt
+- SFX_Forgotten_Temple_Emit_Birds
+- SFX_Forgotten_Temple_Emit_Birds_Interior
+- SFX_Fox_Alerted
+- SFX_Fox_Death
+- SFX_Fox_Hurt
+- SFX_Fox_Run
+- SFX_Fox_Sleep
+- SFX_Frog_Alerted
+- SFX_Frog_Croak
+- SFX_Frog_Death
+- SFX_Frog_Hurt
+- SFX_Frog_Idle
+- SFX_Frog_Run
+- SFX_Furnace_Bench_Close
+- SFX_Furnace_Bench_Open
+- SFX_Furnace_Bench_Processing
+- SFX_Furnace_Bench_Processing_Complete
+- SFX_Furnace_Bench_Processing_End
+- SFX_Furnace_Bench_Processing_Failed
+- SFX_Gecko_Alerted
+- SFX_Gecko_Death
+- SFX_Gecko_Hurt
+- SFX_Gem_Break
+- SFX_Gem_Emit_Loop
+- SFX_Generic_Crafting_Failed
+- SFX_Glass_Break
+- SFX_Global_Weather_Thunder
+- SFX_Goat_Run
+- SFX_Goat_Walk
+- SFX_Goblin_Alerted
+- SFX_Goblin_Death
+- SFX_Goblin_Hurt
+- SFX_Goblin_Lobber_Bomb_Bounce
+- SFX_Goblin_Lobber_Bomb_Death
+- SFX_Goblin_Lobber_Bomb_Hit
+- SFX_Goblin_Lobber_Bomb_Miss
+- SFX_Goblin_Run
+- SFX_Goblin_Search
+- SFX_Golem_Earth_Alerted
+- SFX_Golem_Earth_Death
+- SFX_Golem_Earth_Hurt
+- SFX_Golem_Earth_Laydown
+- SFX_Golem_Earth_Slam
+- SFX_Golem_Earth_Slam_Impact
+- SFX_Golem_Earth_Spin
+- SFX_Golem_Earth_Stomp
+- SFX_Golem_Earth_Stomp_Impact
+- SFX_Golem_Earth_Swing
+- SFX_Golem_Earth_Swing_Impact
+- SFX_Golem_Earth_Wake
+- SFX_Golem_Firesteel_Alerted_01
+- SFX_Golem_Firesteel_Alerted_02
+- SFX_Golem_Firesteel_Death
+- SFX_Golem_Firesteel_Laydown
+- SFX_Golem_Firesteel_Wake
+- SFX_Golem_Frost_Alerted
+- SFX_Golem_Frost_Death
+- SFX_Golem_Frost_Hurt
+- SFX_Golem_Frost_Laydown
+- SFX_Golem_Frost_Slam
+- SFX_Golem_Frost_Slam_Impact
+- SFX_Golem_Frost_Spin
+- SFX_Golem_Frost_Stomp
+- SFX_Golem_Frost_Swing
+- SFX_Golem_Frost_Swing_Impact
+- SFX_Golem_Frost_Wake
+- SFX_Golem_Sand_Alerted
+- SFX_Golem_Sand_Death
+- SFX_Golem_Sand_Hurt
+- SFX_Golem_Sand_Laydown
+- SFX_Golem_Sand_Slam
+- SFX_Golem_Sand_Slam_Impact
+- SFX_Golem_Sand_Spin
+- SFX_Golem_Sand_Stomp
+- SFX_Golem_Sand_Stomp_Impact
+- SFX_Golem_Sand_Swing
+- SFX_Golem_Sand_Swing_Impact
+- SFX_Golem_Sand_Wake
+- SFX_Grass_Break
+- SFX_Grass_Build
+- SFX_Grass_Hit
+- SFX_Grass_Land
+- SFX_Grass_Walk
+- SFX_Gravel_Break
+- SFX_Gravel_Build
+- SFX_Gravel_Hit
+- SFX_Gravel_Land
+- SFX_Gravel_Walk
+- SFX_GunPvP_Assault_Rifle_Bullet_Death
+- SFX_GunPvP_Grenade_Frag_Bounce
+- SFX_GunPvP_Grenade_Frag_Death
+- SFX_GunPvP_Grenade_Frag_Hit
+- SFX_GunPvP_Grenade_Frag_Miss
+- SFX_GunPvP_Handgun_Bullet_Death
+- SFX_Gun_Fire
+- SFX_Hand_Crossbow_T1_Block_Impact
+- SFX_Hand_Crossbow_T1_Raise
+- SFX_Hand_Crossbow_T1_Raise_Local
+- SFX_Hand_Crossbow_T1_Shove
+- SFX_Hand_Crossbow_T1_Shove_Local
+- SFX_Hand_Crossbow_T2_Load
+- SFX_Hand_Crossbow_T2_Load_Local
+- SFX_Hand_Crossbow_T2_Reload_Start
+- SFX_Hand_Crossbow_T2_Reload_Start_Local
+- SFX_Handgun_Fire
+- SFX_Handgun_Fire_Local
+- SFX_Hatchet_T1_Swing_RL_Local
+- SFX_Hatchet_T2_Impact_Nice
+- SFX_Health_Potion_High_Drink
+- SFX_Health_Potion_High_Drink_Local
+- SFX_Health_Potion_Low_Drink
+- SFX_Health_Potion_Low_Drink_Local
+- SFX_Hedera_Scream
+- SFX_Hoe_T1_Swing_Down_Local
+- SFX_Hoe_T1_Till
+- SFX_Horse_Alerted
+- SFX_Horse_Death
+- SFX_Horse_Hurt
+- SFX_Horse_Idle
+- SFX_Horse_Sleep
+- SFX_Horse_Wake
+- SFX_Hyena_Alerted
+- SFX_Hyena_Death
+- SFX_Hyena_Hurt
+- SFX_Hyena_Idle
+- SFX_Ice_Ball_Death
+- SFX_Ice_Bolt_Death
+- SFX_Ice_Break
+- SFX_Ice_Build
+- SFX_Ice_Hit
+- SFX_Ice_Item_Impact
+- SFX_Ice_Item_Swing
+- SFX_Ice_Land
+- SFX_Ice_Walk
+- SFX_Incorrect_Tool
+- SFX_Item_Break
+- SFX_Item_Repair
+- SFX_Klops_Alerted
+- SFX_Klops_Death
+- SFX_Klops_Hurt
+- SFX_Klops_Idle
+- SFX_Klops_Run
+- SFX_Kweebec_Plushie_Impact
+- SFX_Lamb_Alerted
+- SFX_Lamb_Death
+- SFX_Lamb_Hurt
+- SFX_Larva_Alerted
+- SFX_Larva_Death
+- SFX_Larva_Despawn
+- SFX_Larva_Hurt
+- SFX_Larva_Spawn
+- SFX_LeavesGround_Break
+- SFX_LeavesGround_Hit
+- SFX_LeavesGround_Land
+- SFX_LeavesGround_Walk
+- SFX_Leaves_Break
+- SFX_Leaves_Hit
+- SFX_Leaves_Walk
+- SFX_Leopard_Snow_Alerted
+- SFX_Leopard_Snow_Death
+- SFX_Leopard_Snow_Hurt
+- SFX_Leopard_Snow_Run
+- SFX_Light_Melee_T1_Block
+- SFX_Light_Melee_T1_Guard_Hit
+- SFX_Light_Melee_T1_Impact
+- SFX_Light_Melee_T1_Lunge
+- SFX_Light_Melee_T1_Lunge_Charge
+- SFX_Light_Melee_T1_Shove
+- SFX_Light_Melee_T1_Swing
+- SFX_Light_Melee_T2_Block
+- SFX_Light_Melee_T2_Guard_Break
+- SFX_Light_Melee_T2_Guard_Hit
+- SFX_Light_Melee_T2_Lunge
+- SFX_Light_Melee_T2_Lunge_Charge
+- SFX_Light_Melee_T2_Swing
+- SFX_Longsword_Special_Impact
+- SFX_Longsword_Special_Swing
+- SFX_Longsword_Steel_Charged_Swing
+- SFX_Longsword_Steel_Impact
+- SFX_Longsword_Steel_Swing
+- SFX_Lumbermill_Bench_Close
+- SFX_Lumbermill_Bench_Open
+- SFX_Lumbermill_Bench_Processing
+- SFX_Mace_T1_Block_Impact
+- SFX_Mace_T1_Impact
+- SFX_Mace_T1_Raise
+- SFX_Mace_T1_Raise_Local
+- SFX_Mace_T1_Shove
+- SFX_Mace_T1_Shove_Local
+- SFX_Mace_T1_Swing
+- SFX_Mace_T1_Swing_Charged
+- SFX_Mace_T1_Swing_Charged_LR_Local
+- SFX_Mace_T1_Swing_Charged_RL_Local
+- SFX_Mace_T1_Swing_Charged_Up_Local
+- SFX_Mace_T1_Swing_LR_Local
+- SFX_Mace_T1_Swing_RL_Local
+- SFX_Mace_T1_Swing_Up_Local
+- SFX_Mace_T2_Impact
+- SFX_Mace_T2_Raise
+- SFX_Mace_T2_Raise_Local
+- SFX_Mace_T2_Signature_Impact
+- SFX_Mace_T2_Signature_Impact_Local
+- SFX_Mace_T2_Signature_Launch
+- SFX_Mace_T2_Signature_Launch_Local
+- SFX_Mace_T2_Swing
+- SFX_Mace_T2_Swing_Charged
+- SFX_Mace_T2_Swing_Charged_LR_Local
+- SFX_Mace_T2_Swing_Charged_RL_Local
+- SFX_Mace_T2_Swing_Charged_Up_Local
+- SFX_Mace_T2_Swing_LR_Local
+- SFX_Mace_T2_Swing_RL_Local
+- SFX_Mace_T2_Swing_Up_Local
+- SFX_Meerkat_Alerted
+- SFX_Meerkat_Death
+- SFX_Meerkat_Hurt
+- SFX_Meerkat_Idle
+- SFX_Memories_Unlock_Local
+- SFX_Metal_Break
+- SFX_Metal_Build
+- SFX_Metal_Hit
+- SFX_Metal_Land
+- SFX_Metal_Walk
+- SFX_Moose_Bull_Alerted
+- SFX_Mouse_Alerted
+- SFX_Mouse_Death
+- SFX_Mouse_Flee
+- SFX_Mouse_Hurt
+- SFX_Mouse_Run
+- SFX_Mouse_Sleep
+- SFX_Mud_Break
+- SFX_Mud_Build
+- SFX_Mud_Hit
+- SFX_Mud_Land
+- SFX_Mud_Walk
+- SFX_Mug_Fill
+- SFX_Mug_Fill_Local
+- SFX_Mushroom_Break
+- SFX_Mushroom_Harvest
+- SFX_Music_Ducking_2db
+- SFX_NPC_Unarmed_Impact
+- SFX_NPC_Unarmed_Swing
+- SFX_Ore_Break
+- SFX_Ore_Hit
+- SFX_Outlander_Hunter_Arrow_Hit
+- SFX_Outlander_Hunter_Arrow_Miss
+- SFX_Outlander_Hurt
+- SFX_Owl_Alerted
+- SFX_Owl_Death
+- SFX_Owl_Hurt
+- SFX_Pickaxe_T1_Swing_Down_Local
+- SFX_Pickaxe_T2_Impact_Nice
+- SFX_Pig_Alerted
+- SFX_Pig_Death
+- SFX_Pig_Hurt
+- SFX_Pig_Run
+- SFX_Pig_Walk
+- SFX_Pigeon_Death
+- SFX_Pigeon_Hurt
+- SFX_Piglet_Alerted
+- SFX_Piglet_Death
+- SFX_Piglet_Hurt
+- SFX_Piglet_Run
+- SFX_Pistol_Fire
+- SFX_Plant_Break
+- SFX_Plant_Hit
+- SFX_Plant_MoveIn
+- SFX_Player_Climb_Down
+- SFX_Player_Climb_Side
+- SFX_Player_Climb_Up
+- SFX_Player_Craft_Item_Inventory
+- SFX_Player_Death
+- SFX_Player_Death_Drown
+- SFX_Player_Death_Fall
+- SFX_Player_Drop_Item
+- SFX_Player_Fall
+- SFX_Player_Glide_Motion
+- SFX_Player_Glide_Stationary
+- SFX_Player_Grab_Item
+- SFX_Player_Hurt
+- SFX_Player_Hurt_Burn
+- SFX_Player_Hurt_Drowning
+- SFX_Player_Hurt_Fall
+- SFX_Player_Jump
+- SFX_Player_Mantle
+- SFX_Player_Pickup_Item
+- SFX_Player_Roll
+- SFX_Player_Slide
+- SFX_Player_Swim
+- SFX_Player_Swim_Fast
+- SFX_Player_Swim_Jump
+- SFX_Player_Unarmed_Swing_Left
+- SFX_Player_Unarmed_Swing_Right
+- SFX_Plushie_Break
+- SFX_Plushie_Build
+- SFX_Poop_Bounce
+- SFX_Poop_Break
+- SFX_Poop_Hit
+- SFX_Poop_Walk
+- SFX_Portal_Neutral
+- SFX_Portal_Neutral_Open
+- SFX_Portal_Neutral_Teleport_Local
+- SFX_Portal_Void
+- SFX_Potion_Drink_Success
+- SFX_Processing_Placeholder
+- SFX_Projectile_Poop_Hit
+- SFX_Rabbit_Alerted
+- SFX_Rabbit_Death
+- SFX_Rabbit_Hurt
+- SFX_Rabbit_Run
+- SFX_Rabbit_Sleep
+- SFX_Ram_Alerted
+- SFX_Ram_Death
+- SFX_Ram_Hurt
+- SFX_Ram_Run
+- SFX_Ram_Sleep
+- SFX_Raptor_Cave_Alerted
+- SFX_Raptor_Cave_Idle
+- SFX_Rat_Death
+- SFX_Rat_Hurt
+- SFX_Raven_Alerted
+- SFX_Raven_Death
+- SFX_Raven_Flee
+- SFX_Raven_Hurt
+- SFX_Reeds_MoveIn
+- SFX_Rifle_Fire
+- SFX_Rifle_Fire_Local
+- SFX_Rope_Break
+- SFX_Rope_Build
+- SFX_Rope_Land
+- SFX_Rope_Walk
+- SFX_Rotate_Pitch_Default
+- SFX_Rotate_Roll_Default
+- SFX_Rotate_Yaw_Default
+- SFX_Rubble_Bounce
+- SFX_Rubble_Hit
+- SFX_Sand_Break
+- SFX_Sand_Build
+- SFX_Sand_Hit
+- SFX_Sand_Land
+- SFX_Sand_Walk
+- SFX_Scarak_Fighter_Alerted
+- SFX_Scarak_Fighter_Death
+- SFX_Scarak_Fighter_Hurt
+- SFX_Scarak_Seeker_Alerted
+- SFX_Scarak_Seeker_Death
+- SFX_Scarak_Seeker_Hurt
+- SFX_Scarak_Seeker_Spitball_Death
+- SFX_Scarak_Spitball_Fire
+- SFX_Scorpion_Alerted
+- SFX_Scorpion_Death
+- SFX_Scorpion_Run
+- SFX_Scorpion_Threaten
+- SFX_Seeds_Place
+- SFX_Shark_Death
+- SFX_Shark_Dive
+- SFX_Shark_Hurt
+- SFX_Shark_Swim
+- SFX_Shears_Activate
+- SFX_Sheep_Alerted
+- SFX_Sheep_Death
+- SFX_Sheep_Hurt
+- SFX_Sheep_Run
+- SFX_Sheep_Sheared
+- SFX_Sheep_Walk
+- SFX_Shield_T1_Break
+- SFX_Shield_T1_Impact
+- SFX_Shield_T1_Raise
+- SFX_Shield_T1_Raise_Local
+- SFX_Shield_T1_Swing
+- SFX_Shield_T1_Swing_Local
+- SFX_Shield_T2_Impact
+- SFX_Shield_T2_Raise
+- SFX_Shield_T2_Raise_Local
+- SFX_Shield_T2_Swing
+- SFX_Shield_T2_Swing_Local
+- SFX_Shovel_T1_Swing_RL_Local
+- SFX_Shovel_T2_Impact_Nice
+- SFX_Skeleton_Alerted
+- SFX_Skeleton_Death_1
+- SFX_Skeleton_Death_2
+- SFX_Skeleton_Death_3
+- SFX_Skeleton_Death_4
+- SFX_Skeleton_Despawn_1
+- SFX_Skeleton_Despawn_2
+- SFX_Skeleton_Hurt
+- SFX_Skeleton_Mage_Spellbook_Charge
+- SFX_Skeleton_Mage_Spellbook_Impact
+- SFX_Skeleton_Praetorian_Alerted
+- SFX_Skeleton_Praetorian_Death_1
+- SFX_Skeleton_Praetorian_Death_2
+- SFX_Skeleton_Praetorian_Death_3
+- SFX_Skeleton_Praetorian_Death_4
+- SFX_Skeleton_Praetorian_Despawn_1
+- SFX_Skeleton_Praetorian_Despawn_2
+- SFX_Skeleton_Praetorian_Hurt
+- SFX_Skeleton_Praetorian_Run
+- SFX_Skeleton_Praetorian_Search_2
+- SFX_Skeleton_Praetorian_Spawn_1
+- SFX_Skeleton_Praetorian_Walk
+- SFX_Skeleton_Run
+- SFX_Skeleton_Search_2
+- SFX_Skeleton_Spawn_1
+- SFX_Skeleton_Spawn_2
+- SFX_Skeleton_Walk
+- SFX_Snake_Alerted
+- SFX_Snake_Death
+- SFX_Snake_Hurt
+- SFX_Snake_Idle
+- SFX_Snow_Break
+- SFX_Snow_Build
+- SFX_Snow_Hit
+- SFX_Snow_Land
+- SFX_Snow_Walk
+- SFX_Soft_Break
+- SFX_Soft_Build
+- SFX_Soft_Hit
+- SFX_Soft_Land
+- SFX_Soft_Walk
+- SFX_Spark_Living_Alerted
+- SFX_Spark_Living_Death
+- SFX_Sparrow_Alerted
+- SFX_Sparrow_Death
+- SFX_Sparrow_Hurt
+- SFX_Sparrow_Idle
+- SFX_Spawn_Void_Alerted
+- SFX_Spawn_Void_Attack
+- SFX_Spawn_Void_Death
+- SFX_Spawn_Void_Hurt
+- SFX_Spawn_Void_Run
+- SFX_Spear_Impact
+- SFX_Spear_Lunge
+- SFX_Spear_Lunge_Local
+- SFX_Spear_Miss
+- SFX_Spear_Projectile_Impact
+- SFX_Spear_Throw
+- SFX_Spear_Throw_Charge
+- SFX_Spear_Throw_Charge_Local
+- SFX_Spear_Throw_Local
+- SFX_Spider_Alerted
+- SFX_Spider_Death
+- SFX_Spider_Run
+- SFX_Spirit_Root_Alerted
+- SFX_Spirit_Root_Death_01
+- SFX_Spirit_Root_Death_02
+- SFX_Spirit_Root_Hurt
+- SFX_Spirit_Root_Spawn
+- SFX_Squirrel_Alerted
+- SFX_Squirrel_Death
+- SFX_Squirrel_Hurt
+- SFX_Squirrel_Run
+- SFX_Staff_Charged_Loop
+- SFX_Staff_Fire_Shoot
+- SFX_Staff_Flame_Consume_Charge_1
+- SFX_Staff_Flame_Consume_Charge_1_Local
+- SFX_Staff_Flame_Consume_Charge_2
+- SFX_Staff_Flame_Consume_Charge_2_Local
+- SFX_Staff_Flame_Consume_Charge_3
+- SFX_Staff_Flame_Consume_Charge_3_Local
+- SFX_Staff_Flame_Consume_Charge_4
+- SFX_Staff_Flame_Consume_Charge_4_Local
+- SFX_Staff_Flame_Fireball_Impact
+- SFX_Staff_Flame_Fireball_Launch
+- SFX_Staff_Flame_Fireball_Launch_Local
+- SFX_Staff_Flame_Flamethrower
+- SFX_Staff_Flame_Flamethrower_End
+- SFX_Staff_Flame_Flamethrower_End_Local
+- SFX_Staff_Flame_Flamethrower_Impact
+- SFX_Staff_Flame_Flamethrower_Local
+- SFX_Staff_Flame_Trap_Deploy
+- SFX_Staff_Flame_Trap_Despawn
+- SFX_Staff_Flame_Trap_Loop
+- SFX_Staff_Ice_Shoot
+- SFX_Stamina_Potion_Success
+- SFX_Sticks_Break
+- SFX_Stone_Break
+- SFX_Stone_Build
+- SFX_Stone_Coffin_Open_Close
+- SFX_Stone_Harvest
+- SFX_Stone_Hit
+- SFX_Stone_Land
+- SFX_Stone_Walk
+- SFX_Sword_T1_Block_Local
+- SFX_Sword_T1_Lunge_Charge_Local
+- SFX_Sword_T1_Lunge_Local
+- SFX_Sword_T1_Shove_Local
+- SFX_Sword_T1_Swing_Down_Local
+- SFX_Sword_T1_Swing_LR_Local
+- SFX_Sword_T1_Swing_RL_Local
+- SFX_Sword_T2_Block_Local
+- SFX_Sword_T2_Impact
+- SFX_Sword_T2_Lunge_Charge_Local
+- SFX_Sword_T2_Lunge_Local
+- SFX_Sword_T2_Signature_Part_1
+- SFX_Sword_T2_Signature_Part_1_Local
+- SFX_Sword_T2_Signature_Part_2
+- SFX_Sword_T2_Signature_Part_2_Local
+- SFX_Sword_T2_Swing_Down_Local
+- SFX_Sword_T2_Swing_LR_Local
+- SFX_Sword_T2_Swing_RL_Local
+- SFX_T1_Impact_Blunt
+- SFX_Tall_Grass_MoveIn
+- SFX_Test_Blip_A
+- SFX_Test_Blip_B
+- SFX_Test_Blip_C
+- SFX_Tetrabird_Alerted
+- SFX_Tetrabird_Death
+- SFX_Tetrabird_Flee
+- SFX_Tetrabird_Hurt
+- SFX_Tetrabird_Run
+- SFX_Tiger_Sabertooth_Alerted
+- SFX_Tiger_Sabertooth_Death
+- SFX_Tiger_Sabertooth_Hurt
+- SFX_Tiger_Sabertooth_Run
+- SFX_Toad_Rhino_Alerted
+- SFX_Toad_Rhino_Death
+- SFX_Toad_Rhino_Hurt
+- SFX_Toad_Rhino_Magma_Alerted
+- SFX_Toad_Rhino_Magma_Death
+- SFX_Toad_Rhino_Magma_Hurt
+- SFX_Toad_Rhino_Magma_Run
+- SFX_Toad_Rhino_Magma_Tongue_Impact
+- SFX_Toad_Rhino_Magma_Tongue_Whoosh
+- SFX_Toad_Rhino_Run
+- SFX_Toad_Rhino_Tongue_Impact
+- SFX_Toad_Rhino_Tongue_Whoosh
+- SFX_Tombstone_Break
+- SFX_Tool_T1_Swing
+- SFX_Tool_Watering_Can_Water
+- SFX_Torch_Break
+- SFX_Torch_Build
+- SFX_Torch_Default_Loop
+- SFX_Torch_Impact
+- SFX_Torch_Off
+- SFX_Torch_On_Loop
+- SFX_Torch_Swing
+- SFX_Torch_Swing_Left_Local
+- SFX_Torch_Swing_Right_Local
+- SFX_Tornado
+- SFX_Trashpile_Land
+- SFX_Trashpile_Walk
+- SFX_Trork_Alerted
+- SFX_Trork_Chieftain_Alerted
+- SFX_Trork_Chieftain_Death
+- SFX_Trork_Chieftain_Hurt
+- SFX_Trork_Chieftain_Run
+- SFX_Trork_Chieftain_Search
+- SFX_Trork_Death
+- SFX_Trork_Exertion
+- SFX_Trork_Hurt_01
+- SFX_Trork_Hurt_02
+- SFX_Trork_Run
+- SFX_Trork_Search
+- SFX_Trork_Sleep
+- SFX_Trork_Throwing_Axe
+- SFX_Unarmed_Impact
+- SFX_Unarmed_Swing
+- SFX_Unbreakable_Block
+- SFX_Vulture_Alerted
+- SFX_Vulture_Death
+- SFX_Vulture_Flee
+- SFX_Vulture_Hurt
+- SFX_Wand_Fire_Shoot
+- SFX_Wand_Ice_Shoot
+- SFX_Warthog_Alerted
+- SFX_Warthog_Death
+- SFX_Warthog_Hurt
+- SFX_Warthog_Piglet_Alerted
+- SFX_Warthog_Piglet_Death
+- SFX_Warthog_Piglet_Hurt
+- SFX_Warthog_Piglet_Run
+- SFX_Warthog_Run
+- SFX_Warthog_Sleep
+- SFX_Warthog_Walk
+- SFX_Water_MoveIn
+- SFX_Water_MoveOut
+- SFX_Weapon_Bench_Close
+- SFX_Weapon_Bench_Craft
+- SFX_Weapon_Bench_Open
+- SFX_Weapon_Charge_Swing
+- SFX_Web_MoveIn
+- SFX_Window_Break
+- SFX_Window_Stone_Break
+- SFX_Wisp_Lamp_Loop
+- SFX_Wolf_Alerted
+- SFX_Wolf_Death
+- SFX_Wolf_Hurt
+- SFX_Wolf_Run
+- SFX_Wolf_Sleep
+- SFX_Wood_Break
+- SFX_Wood_Build
+- SFX_Wood_Hit
+- SFX_Wood_Land
+- SFX_Wood_Walk
+- SFX_Woodpecker_Death
+- SFX_Woodpecker_Hurt
+- SFX_Workbench_Close
+- SFX_Workbench_Craft
+- SFX_Workbench_Open
+- SFX_Workbench_Upgrade_Complete_Default
+- SFX_Workbench_Upgrade_Start_Default
+- SFX_Yeti_Alerted
+- SFX_Z1_Emit_Forest_Autumn_Day_Birds
+- SFX_Z1_Emit_Forest_Autumn_Day_Insects
+- SFX_Z1_Emit_Forest_Autumn_Day_Wind
+- SFX_Z1_Emit_Forest_Azure_Day_Insects
+- SFX_Z1_Emit_Forest_Azure_Day_Wind
+- SFX_Z1_Emit_Forest_Gen_Day_Birds
+- SFX_Z1_Emit_Forest_Gen_Day_Insects
+- SFX_Z1_Emit_Forest_Gen_Day_Winds
+- SFX_Z1_Emit_Forest_Moss_Day_Birds
+- SFX_Z1_Emit_Forest_Moss_Day_Insects
+- SFX_Z1_Emit_Forest_Moss_Day_Wind
+- SFX_Z1_Emit_Forest_Night_Birds
+- SFX_Z1_Emit_Forest_Night_Insects
+- SFX_Z1_Emit_Forest_Night_Wind
+- SFX_Z1_Emit_Kweebec_Village_Wind
+- SFX_Z1_Emit_Mountain_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Insects
+- SFX_Z1_Emit_Plains_Gen_Day_Wind
+- SFX_Z1_Emit_Plains_Gen_Night_Birds
+- SFX_Z1_Emit_Plains_Gen_Night_Insects
+- SFX_Z1_Emit_Plains_Gen_Night_Wind
+- SFX_Z1_Emit_Shore_Day_Birds
+- SFX_Z1_Emit_Shore_Waves
+- SFX_Z1_Emit_Shore_Wind
+- SFX_Z1_Emit_Swamp_Day_Birds
+- SFX_Z1_Emit_Swamp_Day_Frogs
+- SFX_Z1_Emit_Swamp_Day_Insects
+- SFX_Z1_Emit_Swamp_Day_Wind
+- SFX_Z1_Emit_Swamp_Night_Frogs
+- SFX_Z1_Emit_Trork_Camp
+- SFX_Z1_Shore_Day_Birds
+- SFX_Z3_Emit_Cave_Ice_Crackle
+- SFX_Z3_Emit_Cave_Ice_Rumble
+- SFX_Z3_Emit_Cave_Ice_Stress
+- SFX_Z3_Emit_Cave_Snow_Crackle
+- SFX_Z3_Emit_Cave_Snow_Melt
+- SFX_Z3_Emit_Hedera_FX
+- SFX_Z3_Emit_Hedera_PlantRustle
+- SFX_Z3_Emit_Tree_Creak
+- SFX_Z3_Emit_Wind_Leaves
+- SFX_Z3_Emit_Wind_Leaves_Stereo
+- SFX_Z3_Forest_Day_Birds
+- SFX_Z3_Forest_Day_General
+- SFX_Z3_Forest_Night_Birds
+- SFX_Zombie_Alerted
+- SFX_Zombie_Attack_Bite
+- SFX_Zombie_Attack_Swing
+- SFX_Zombie_Death
+- SFX_Zombie_Despawn
+- SFX_Zombie_Hurt
+- SFX_Zombie_Pursuit
+- SFX_Zombie_ScratchBack
+- SFX_Zombie_Spawn
diff --git a/content/docs/sv-SE/guides/ecs/entity-component-system.mdx b/content/docs/sv-SE/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/sv-SE/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/sv-SE/guides/ecs/example-ecs-plugin.mdx b/content/docs/sv-SE/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/sv-SE/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/sv-SE/guides/ecs/hytale-ecs-theory.mdx b/content/docs/sv-SE/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/sv-SE/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/sv-SE/guides/ecs/systems.mdx b/content/docs/sv-SE/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/sv-SE/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/sv-SE/guides/java-basics/00-introduction.mdx b/content/docs/sv-SE/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/sv-SE/guides/java-basics/00-introduction.mdx
+++ b/content/docs/sv-SE/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/sv-SE/guides/java-basics/06-methods-functions.mdx b/content/docs/sv-SE/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/sv-SE/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/sv-SE/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/sv-SE/guides/plugin/block-components.mdx b/content/docs/sv-SE/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/sv-SE/guides/plugin/browsing-serverjar.mdx b/content/docs/sv-SE/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/sv-SE/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/sv-SE/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/sv-SE/guides/plugin/build-and-test.mdx b/content/docs/sv-SE/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/sv-SE/guides/plugin/chat-formatting.mdx b/content/docs/sv-SE/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/sv-SE/guides/plugin/chat-formatting.mdx
+++ b/content/docs/sv-SE/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/sv-SE/guides/plugin/client-inputs-reference.mdx b/content/docs/sv-SE/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/sv-SE/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/sv-SE/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/sv-SE/guides/plugin/creating-block.mdx b/content/docs/sv-SE/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/sv-SE/guides/plugin/creating-block.mdx
+++ b/content/docs/sv-SE/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/sv-SE/guides/plugin/creating-commands.mdx b/content/docs/sv-SE/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/sv-SE/guides/plugin/creating-commands.mdx
+++ b/content/docs/sv-SE/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/sv-SE/guides/plugin/creating-configuration-file.mdx b/content/docs/sv-SE/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/sv-SE/guides/plugin/creating-events.mdx b/content/docs/sv-SE/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/sv-SE/guides/plugin/creating-events.mdx
+++ b/content/docs/sv-SE/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/sv-SE/guides/plugin/customizing-camera-controls.mdx b/content/docs/sv-SE/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/sv-SE/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/sv-SE/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/sv-SE/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/sv-SE/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/sv-SE/guides/plugin/instances.mdx b/content/docs/sv-SE/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/sv-SE/guides/plugin/inventory-management.mdx b/content/docs/sv-SE/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/sv-SE/guides/plugin/inventory-management.mdx
+++ b/content/docs/sv-SE/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/sv-SE/guides/plugin/item-interaction.mdx b/content/docs/sv-SE/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/sv-SE/guides/plugin/listening-to-packets.mdx b/content/docs/sv-SE/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/sv-SE/guides/plugin/logging.mdx b/content/docs/sv-SE/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/sv-SE/guides/plugin/player-death-event.mdx b/content/docs/sv-SE/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/sv-SE/guides/plugin/player-input-guide.mdx b/content/docs/sv-SE/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/sv-SE/guides/plugin/player-input-guide.mdx
+++ b/content/docs/sv-SE/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/sv-SE/guides/plugin/player-stats.mdx b/content/docs/sv-SE/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/sv-SE/guides/plugin/setting-up-env.mdx b/content/docs/sv-SE/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/sv-SE/guides/plugin/setting-up-env.mdx
+++ b/content/docs/sv-SE/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/sv-SE/guides/plugin/spawning-entities.mdx b/content/docs/sv-SE/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/sv-SE/guides/plugin/spawning-entities.mdx
+++ b/content/docs/sv-SE/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/sv-SE/guides/plugin/spawning-npcs.mdx b/content/docs/sv-SE/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/sv-SE/guides/plugin/store-persistant-data.mdx b/content/docs/sv-SE/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/sv-SE/guides/plugin/teleporting-players.mdx b/content/docs/sv-SE/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/sv-SE/guides/plugin/teleporting-players.mdx
+++ b/content/docs/sv-SE/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/sv-SE/guides/plugin/text-hologram.mdx b/content/docs/sv-SE/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/sv-SE/guides/plugin/ui.mdx b/content/docs/sv-SE/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/sv-SE/guides/plugin/world-gen.mdx b/content/docs/sv-SE/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/sv-SE/guides/plugin/world-gen.mdx
+++ b/content/docs/sv-SE/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/sv-SE/guides/prefabs.mdx b/content/docs/sv-SE/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/sv-SE/guides/prefabs.mdx
+++ b/content/docs/sv-SE/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/sv-SE/official-documentation/npc-doc.mdx b/content/docs/sv-SE/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/sv-SE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/sv-SE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/sv-SE/publishing/builtbybit.mdx b/content/docs/sv-SE/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/sv-SE/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/sv-SE/publishing/index.mdx b/content/docs/sv-SE/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/sv-SE/publishing/index.mdx
+++ b/content/docs/sv-SE/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/tr-TR/guides/ecs/entity-component-system.mdx b/content/docs/tr-TR/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/tr-TR/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/tr-TR/guides/ecs/example-ecs-plugin.mdx b/content/docs/tr-TR/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/tr-TR/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/tr-TR/guides/ecs/hytale-ecs-theory.mdx b/content/docs/tr-TR/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/tr-TR/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/tr-TR/guides/ecs/systems.mdx b/content/docs/tr-TR/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/tr-TR/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/tr-TR/guides/java-basics/00-introduction.mdx b/content/docs/tr-TR/guides/java-basics/00-introduction.mdx
index 0d080397..2198df86 100644
--- a/content/docs/tr-TR/guides/java-basics/00-introduction.mdx
+++ b/content/docs/tr-TR/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/tr-TR/guides/java-basics/06-methods-functions.mdx b/content/docs/tr-TR/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/tr-TR/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/tr-TR/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/tr-TR/guides/plugin/block-components.mdx b/content/docs/tr-TR/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/tr-TR/guides/plugin/browsing-serverjar.mdx b/content/docs/tr-TR/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/tr-TR/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/tr-TR/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/tr-TR/guides/plugin/build-and-test.mdx b/content/docs/tr-TR/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/tr-TR/guides/plugin/chat-formatting.mdx b/content/docs/tr-TR/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/tr-TR/guides/plugin/chat-formatting.mdx
+++ b/content/docs/tr-TR/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/tr-TR/guides/plugin/client-inputs-reference.mdx b/content/docs/tr-TR/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/tr-TR/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/tr-TR/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/tr-TR/guides/plugin/creating-block.mdx b/content/docs/tr-TR/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/tr-TR/guides/plugin/creating-block.mdx
+++ b/content/docs/tr-TR/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/tr-TR/guides/plugin/creating-commands.mdx b/content/docs/tr-TR/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/tr-TR/guides/plugin/creating-commands.mdx
+++ b/content/docs/tr-TR/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/tr-TR/guides/plugin/creating-configuration-file.mdx b/content/docs/tr-TR/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/tr-TR/guides/plugin/creating-events.mdx b/content/docs/tr-TR/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/tr-TR/guides/plugin/creating-events.mdx
+++ b/content/docs/tr-TR/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/tr-TR/guides/plugin/customizing-camera-controls.mdx b/content/docs/tr-TR/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/tr-TR/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/tr-TR/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/tr-TR/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/tr-TR/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/tr-TR/guides/plugin/instances.mdx b/content/docs/tr-TR/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/tr-TR/guides/plugin/inventory-management.mdx b/content/docs/tr-TR/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/tr-TR/guides/plugin/inventory-management.mdx
+++ b/content/docs/tr-TR/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/tr-TR/guides/plugin/item-interaction.mdx b/content/docs/tr-TR/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/tr-TR/guides/plugin/listening-to-packets.mdx b/content/docs/tr-TR/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/tr-TR/guides/plugin/logging.mdx b/content/docs/tr-TR/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/tr-TR/guides/plugin/player-death-event.mdx b/content/docs/tr-TR/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/tr-TR/guides/plugin/player-input-guide.mdx b/content/docs/tr-TR/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/tr-TR/guides/plugin/player-input-guide.mdx
+++ b/content/docs/tr-TR/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/tr-TR/guides/plugin/player-stats.mdx b/content/docs/tr-TR/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/tr-TR/guides/plugin/setting-up-env.mdx b/content/docs/tr-TR/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/tr-TR/guides/plugin/setting-up-env.mdx
+++ b/content/docs/tr-TR/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/tr-TR/guides/plugin/spawning-entities.mdx b/content/docs/tr-TR/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/tr-TR/guides/plugin/spawning-entities.mdx
+++ b/content/docs/tr-TR/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/tr-TR/guides/plugin/spawning-npcs.mdx b/content/docs/tr-TR/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/tr-TR/guides/plugin/store-persistant-data.mdx b/content/docs/tr-TR/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/tr-TR/guides/plugin/teleporting-players.mdx b/content/docs/tr-TR/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/tr-TR/guides/plugin/teleporting-players.mdx
+++ b/content/docs/tr-TR/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/tr-TR/guides/plugin/text-hologram.mdx b/content/docs/tr-TR/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/tr-TR/guides/plugin/ui.mdx b/content/docs/tr-TR/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/tr-TR/guides/plugin/world-gen.mdx b/content/docs/tr-TR/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/tr-TR/guides/plugin/world-gen.mdx
+++ b/content/docs/tr-TR/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/tr-TR/guides/prefabs.mdx b/content/docs/tr-TR/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/tr-TR/guides/prefabs.mdx
+++ b/content/docs/tr-TR/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/tr-TR/official-documentation/npc-doc.mdx b/content/docs/tr-TR/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/tr-TR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/tr-TR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/tr-TR/publishing/builtbybit.mdx b/content/docs/tr-TR/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/tr-TR/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/tr-TR/publishing/index.mdx b/content/docs/tr-TR/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/tr-TR/publishing/index.mdx
+++ b/content/docs/tr-TR/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/uk-UA/contributing/pr-guidelines.mdx b/content/docs/uk-UA/contributing/pr-guidelines.mdx
index 59a53fa4..c77be572 100644
--- a/content/docs/uk-UA/contributing/pr-guidelines.mdx
+++ b/content/docs/uk-UA/contributing/pr-guidelines.mdx
@@ -16,24 +16,24 @@ description: Настанови, які критики та меценати п
    - У своєму заголовку запиту на злиття додайте `GH-ISSUE-NUMBER`, щоб прив'язати запит на злиття  до відповідної проблеми. Це необхідно для всіх запитів на злиття.
 3. **Невеликі, цілеспрямовані зміни**
    - Прагніть робити запит на злиття невеликими та зосередженими на одній проблемі чи функції. Це спрощує розуміння та надання зворотного зв'язку.
-4. **Code Quality**
-   - Ensure your code follows the project's coding standards and best practices.
-   - Include comments where necessary to explain complex logic.
-5. **Testing**
-   - Test your changes thoroughly before submitting the PR.
-   - If applicable, include unit tests or integration tests to verify your changes.
-6. **Documentation**
-   - Update or add documentation as needed to reflect your changes.
-7. **Commit Messages**
-   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
-8. **Check for Conflicts**
-   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+4. **Якість коду**
+   - Переконайтеся, що ваш код дотримується стандартів кодування та найкращих практик проєкту.
+   - Вносьте коментарі, де необхідно пояснити складну логіку.
+5. **Тестування**
+   - Перевірте свої зміни перед надсиланням запиту на злиття.
+   - Якщо можливо, додайте модульні або інтеграційні тести для перевірки ваших змін.
+6. **Документація**
+   - Оновіть або додайте документацію за потреби, щоб показати ваші зміни.
+7. **Повідомлення фіксації**
+   - Використовуйте чіткі та описані повідомлення для фіксацій, які слідують [традиційним фіксам](https://www.conventionalcommits.org/en/v1.0.0/).
+8. **Перевірка конфліктів**
+   - Перед надсиланням свого запиту на злиття, переконайтеся, що ваша гілка в актуальному стані з основною гілкою щоб мінімізувати конфлікти злиття.
 
-## For Reviewers
+## Для критиків
 
-- You are supposed to review PRs thoroughly, and request changes if needed.
-- Provide constructive feedback and suggestions for improvement.
-- Verify that the changes meet the project's coding standards and best practices.
-- Deploy the PR using the dokploy integration to ensure the changes work as expected.
-- Ensure that documentation is updated as necessary.
-- Approve the PR only when you are satisfied with the changes and all checks have passed.
+- Ви повинні ретельно переглядати запит на злиття, і запитувати зміни, якщо це необхідно.
+- Надати конструктивний зворотний зв'язок і пропозиції для вдосконалення.
+- Переконайтеся, що зміни відповідають стандартам кодування проєкту та найкращій практиці.
+- Розгорніть запит на злиття за допомогою інтеграції dokploy, щоб переконатися, що зміни працюють належним чином.
+- Переконайтеся, що документація оновлена за необхідності.
+- Затвердити запит на злиття лише тоді, коли ви задоволені змінами й всі перевірки пройшли.
diff --git a/content/docs/uk-UA/contributing/writing-guides.mdx b/content/docs/uk-UA/contributing/writing-guides.mdx
index 19069dde..590f1358 100644
--- a/content/docs/uk-UA/contributing/writing-guides.mdx
+++ b/content/docs/uk-UA/contributing/writing-guides.mdx
@@ -14,7 +14,7 @@ title: Написання інструкцій
 
 ## Передній план
 
-Передній план - це метадані вашого посібника, він розказує нам як відображати вашу інструкцію. Це має бути в верхній частині файлу, який починається з `---` і закінчується `---`.
+Передній план - це метадані вашого посібника, він розказує нам як зображати вашу інструкцію. Це має бути в верхній частині файлу, який починається з `---` і закінчується `---`.
 
 Ось приклад:
 
@@ -23,7 +23,7 @@ title: Написання інструкцій
 title: "Основи Java"
 description: "Вивчіть основи програмування Java."
 authors:
-    - name: "Ваше Ім'я"
+   - name: "Ваше Ім'я"
       url: "https://yourwebsite.com"
 ---
 ```
@@ -34,53 +34,53 @@ authors:
 
 ## Структура контенту
 
-Потрібно структурувати зміст свого керівництва чітким і організованим. Here are some tips on how to do that:
+Потрібно структурувати зміст свого керівництва чітким і організованим. Ось кілька порад про те, як це зробити:
 
-- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
-- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
-- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
-- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
-- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+- **Вступ:** Почніть з огляду теми та того, що може вивчити читач.
+- **Передумови:** Перелічіть будь-які передумови або попередні знання, які читач повинен мати, перш ніж поглибитися до посібника.
+- **Покрокові інструкції:** Розбивайте вміст у чіткі кроки. Використовуйте заголовки та підзаголовки для організації інформації.
+- **Приклади коду:** Додайте фрагменти коду для ілюстрації ключових моментів. Обов'язково поясніть кожен приклад ретельно.
+- **Висновок:** Підсумуйте основні тези та заохочуйте читача до подальшого вивчення або спроби того, що він дізнався.
 
-Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+Тепер, якщо ви пишете справді великий розділ, вам слід розділити його на кілька сторінок, щоб читачеві було легше засвоїти інформацію. Ніхто не хоче читати велику стіну тексту!
 
-When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+Коли ми пишемо інструкції, ми також повинні думати про те, як люди будуть споживати їх, і багато людей віддають перевагу стислому змісту, а не читати детально. Ось чому розділити інформацію на кілька сторінок, тому для читача вона виглядає як менша кількість інформації. Також розгляньте можливість використання маркованих списків, нумерованих списків та інших методів форматування, щоб зробити вміст легшим для читання.
 
-## Formatting
+## Форматування
 
-We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+Ми використовуємо [Markdown](https://www.markdownguide.org/) для форматування наших посібників. Ось кілька ключових моментів, які слід пам’ятати:
 
-- Use headings (`#`, `##`, `###`) to organize your content.
-- Use bullet points and numbered lists for clarity.
+- Використання заголовків (`#`, `##`, `###`) для організації вмісту.
+- Використовуйте марковані списки та нумеровані списки для ясності.
 - Use code blocks (\`\`\`) for code snippets.
-- Use links to reference other guides or external resources.
+- Використовуйте посилання для ознайомлення з іншими посібниками або зовнішніми ресурсами.
 
-This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+Це той самий тип форматування, який ви побачите на більшості вебсайтів з документацією, а також на платформах соціальних мереж, таких як Discord.
 
-You can also make a Callout to highlight important information or tips. Use the following syntax:
+Ви також можете зробити виноску, щоб виділити важливу інформацію або поради.  Використовуйте наступний синтаксис:
 
 ```mdx
 <Callout>
-    This is a callout message.
+Це виноска.
 </Callout>
 ```
 
 <Callout>
-  This is a callout message.
+  Це виноска.
 </Callout>
 
-You can change the color of the callout by adding a `type` attribute. For example:
+Ви можете змінити колір виклику додавши атрибут `type`. Наприклад:
 
 ```mdx
 <Callout type="info">
-    This is an info callout.
+    Це інформаційна виноска.
 </Callout>
 ```
 
-Available types are: `info`, `warning`, `error`, and `success`.
+Доступні типи: `info`, `warning`, `error` та `success`.
 
-## Conclusion
+## Висновок
 
-That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+От і все! Тепер ви майстер написання інструкцій. Просто пам’ятайте, що не думайте, що вам потрібно бути ідеальним у своїй мові, пишіть посібник так, як ви поясните тему комусь, і не соромтеся просити відгуків чи допомоги, якщо вам це потрібно.
 
-Happy writing!
+Приємного письма!
diff --git a/content/docs/uk-UA/established-information/client/index.mdx b/content/docs/uk-UA/established-information/client/index.mdx
index e5ea7b88..58d16127 100644
--- a/content/docs/uk-UA/established-information/client/index.mdx
+++ b/content/docs/uk-UA/established-information/client/index.mdx
@@ -4,7 +4,7 @@ description: Інформація щодо клієнта Hytale.
 ---
 
 <Callout>
-  Клієнт написаний на C#, перед розповсюдженням компілюється в машинний код і не піддається модифікації. Однокористувацький режим працює на локальному сервері. Всі модифікації повинні проходити через API сервера.
+  Клієнт написаний на C#, перед розповсюдженням компілюється в машинний код і не піддається модифікації. Однокористувацький режим використовує локальний сервер. Всі модифікації повинні проходити через API сервера.
 </Callout>
 
 # Відсутність клієнтських модифікацій
diff --git a/content/docs/uk-UA/established-information/faq.mdx b/content/docs/uk-UA/established-information/faq.mdx
index b8e68cb1..94e65dad 100644
--- a/content/docs/uk-UA/established-information/faq.mdx
+++ b/content/docs/uk-UA/established-information/faq.mdx
@@ -1,11 +1,11 @@
 ---
-title: Frequently Asked Questions
+title: Найбільш поширенні питання
 description: Часті питання про модинг Hytale.
 ---
 
-On this page, we'll answer some of your Frequently Asked Questions.
+На цій сторінці ми дамо відповідь на деякі часті питання.
 
-## 1. Can the client be modded?
+## 1. Чи можна редагувати клієнт?
 
 No, the client is not able to be modded, although the Client will not have control over how the game and the UI looks.
 
diff --git a/content/docs/uk-UA/established-information/gameplay/creative.mdx b/content/docs/uk-UA/established-information/gameplay/creative.mdx
index c2c4e4b4..e08fc5d6 100644
--- a/content/docs/uk-UA/established-information/gameplay/creative.mdx
+++ b/content/docs/uk-UA/established-information/gameplay/creative.mdx
@@ -1,243 +1,243 @@
 ---
-title: Creative
-description: Information regarding the creative mode in Hytale.
+title: Креатив
+description: Інформація про креатив Hytale.
 ---
 
-# Creative Mode
+# Креатив
 
-Creative mode in Hytale is a sandbox mode that allows players to edit the world freely.
+Креатив у Hytale  - це режим пісочниці, який дозволяє гравцям вільно редагувати світ.
 
-## World Editing Tools
+## Інструменти редагування світу
 
-Creative mode includes a variety of tools to help players edit the world. It includes undo functionality for edits.
+Творчий режим містить різні інструменти, щоб допомогти гравцям редагувати світ. Він включає функцію скасування редагувань.
 
-Note that the below sections were unnamed in the video demo of the tools.
+Зверніть увагу, що наведені нижче розділи не мали назв у відеодемонстрації інструментів.
 
 ---
 
-### Laser Pointer
+### Лазерний вказівник
 
-Displays a ray from the player's camera in the direction the player is looking.
+Відбиває промінь від камери гравця в напрямку, в якому дивиться гравець.
 
-#### Settings
+#### Налаштування
 
-- Duration (Integer Slider): Description unknown as of December 2025.
-- Laser Color (Hex Color Code): Description unknown as of December 2025.
+- Тривалість (цілочисельний повзунок): Опис невідомий станом на грудень 2025 року.
+- Колір лазера (шістнадцятковий код кольору): опис невідомий станом на грудень 2025 року.
 
-### Sculpt Brush Tool
+### Інструмент Скульптурний пензель
 
-Allows the user to raise and lower the terrain to more accurately sculpt and blend shapes. Supports most features of the Paint Brush.
+Дозволяє користувачеві підіймати та опускати рельєф для точнішого формування та поєднання форм. Підтримує більшість функцій пензля для малювання.
 
-### Line Brush Tool
+### Інструмент Лінійний пензель
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Selection Tool
+### Інструмент вибору
 
-Allows the user to select and edit regions of the world by transforming selections of blocks or a prefab via position, rotation, and extrusion.
+Дозволяє користувачеві вибирати та редагувати області світу, трансформуючи вибрані блоки або заготовлення за допомогою позиціювання, обертання та вилучення.
 
-#### Settings
+#### Налаштування
 
-- Mode (Combo Box: Set, Wall, Fill, Replace): Description unknown as of December 2025.
-- Material (Integer Slider): Description unknown as of December 2025.
-- Weight (Integer Slider): Description unknown as of December 2025.
-- Pitch (Integer): Description unknown as of December 2025.
+- Режим (комбінований список: Встановити, Стіна, Заповнити, Замінити): Опис невідомий станом на грудень 2025 року.
+- Матеріал (цілочисельний повзунок): Опис невідомий станом на грудень 2025 року.
+- Вага (цілочисельний повзунок): Опис невідомий станом на грудень 2025 року.
+- Висота тону (ціле число): Опис невідомий станом на грудень 2025 року.
 
-### Ruler
+### Лінійка
 
-Allows the user to measure distances between multiple points in 3D space, with support for multiple measurement lines and editing of measured points.
+Дозволяє користувачеві вимірювати відстані між кількома точками у 3D-просторі, з підтримкою кількох ліній вимірювання та редагуванням виміряних точок.
 
-### Layer Brush Tool
+### Інструмент Шаровий пензель
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Paste Tool
+### Інструмент для вставки
 
-Allows the user to paste a copied selection of blocks or a prefab at the point at which the player is looking. The paste is relative to the selection's anchor point. If the selection is a prefab, the anchor point may be set in the Prefab Editor. It is unknown if the selection's anchor may be set otherwise.
+Дозволяє користувачеві вставити скопійований вибір блоків або заготовлення в точку, на яку дивиться гравець. Вставка здійснюється відносно точки прив'язки виділення. Якщо вибір є заготовленням, точку прив'язки можна встановити в редакторі заготовлення. Невідомо, чи можна встановити якір вибору іншим чином.
 
-### Flood Brush Tool
+### Інструмент Рідинний пензель
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Paint Brush Tool
+### Інструмент Пензель
 
-Brushes are used to make large changes to the world from far away.
+Пензлі використовуються для внесення великих змін у світ здалеку.
 
-#### General Abilities
+#### Загальні здібності
 
-- Place Shapes and Prefabs
-- Replace Blocks
-- Create Axis Locks and Masks
+- Розмістити фігури та заготовлення
+- Замінювати блоки
+- Створення блокувань осей та масок
 
-#### Settings
+#### Налаштування
 
-- Material
-- Width (Integer Slider): Description unknown as of December 2025.
-- Height (Integer Slider): Description unknown as of December 2025.
-- Shape (Combo Box: Cube, Sphere, Cylinder, Cone, Inverted Cone, Pyramid, Inverted Pyramid, Cuboid Grid): Description unknown as of December 2025.
-- Origin (Combo Box: Center, Bottom, Top): Description unknown as of December 2025.
-- Mirror Axis (Combo Box: None, Unknown other options): Description unknown as of December 2025.
-- Wall Thickness (Integer Slider): Description unknown as of December 2025.
-- Density (Integer Slider): Description unknown as of December 2025.
+- Матеріал
+- Ширина (цілочисельний повзунок): Опис невідомий станом на грудень 2025 року.
+- Висота (цілочисельний повзунок): Опис невідомий станом на грудень 2025 року.
+- Форма (комбінований список: куб, сфера, циліндр, конус, перевернутий конус, піраміда, перевернута піраміда, прямокутна сітка): опис невідомий станом на грудень 2025 року.
+- Походження (комбінований список: центр, низ, верх): опис невідомий станом на грудень 2025 року.
+- Дзеркальна вісь (поле списку: Немає, Невідомі інші опції): Опис невідомий станом на грудень 2025 року.
+- Товщина стінки (цілочисельний повзунок): опис невідомий станом на грудень 2025 року.
+- Щільність (повзунок цілого числа): Опис невідомий станом на грудень 2025 року.
 
-#### Presets:
+#### Шаблони:
 
-- Boulder: Creates a boulder at the point at which the player is looking.
-- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
-- Rubble: Generate rubble at the point at which the player is looking.
-- Tentacle: TBD
-- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
-- Hot Springs: TBD
-- Ruins: Generates a ruin at the point at which the player is looking.
-- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
-- Grass: TBD
-- Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
-- Ruins: TBD
+- Валун: Створює валун у точці, на яку дивиться гравець.
+- Трав'яна стежка: Перетворює місцевість на трав'яну стежку в точці, куди дивиться гравець.
+- Щебінь: Генерує щебінь у точці, куди дивиться гравець.
+- Мацаки: уточнюється
+- Лавові тріщини: Перетворює місцевість на лавову тріщину в точці, куди дивиться гравець.
+- Гарячі джерела: уточнюється
+- Руїни: Генерує руїни в точці, на яку дивиться гравець.
+- Дахи руїн: Створює руїни з дахом у точці, куди дивиться гравець.
+- Трава: уточнюється
+- Гора: Розміщує послідовні шматки місцевості, утворюючи гору в точці, на яку дивиться гравець.
+- Руїни: уточнюється
 
 ---
 
-### Entity Grabber Tool
+### Інструмент захоплення об'єктів
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Noise Brush Tool
+### Інструмент Пензель шуму
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Scatter Brush Tool
+### Інструмент Розсіювальний пензель
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Extrude Brush Tool
+### Інструмент Пензель видавлення
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Prefab Selector Tool
+### Інструмент вибору заготовленого матеріалу
 
-Allows the user to select a prefab when inside the Prefab Editor. May be used with the copy command.
+Дозволяє користувачеві вибрати заготовлене у редакторі заготовлених. Може бути використаний з командою копіювання.
 
-### Smooth Brush Tool
+### Інструмент Пензель згладжування
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Hitbox Tool
+### Інструмент зони ураження.
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Set Anchor Tool
+### Інструмент Встановлення якоря
 
-Allows the user to set an anchor point for a prefab when inside the Prefab Editor.
+Дозволяє користувачеві встановити якір для заготовленого всередині редактора заготовлених.
 
-### Tint Brush Tool
+### Інструмент Пензель тонування
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
 ---
 
-## Creative Mode Quick Settings
+## Швидкі налаштування креативу
 
-Note that these are WIP and subject to change. **Not all settings and functionality are currently known**.
+Зверніть увагу, що це незавершені роботи та можуть бути змінені. **Наразі не всі налаштування та функції відомі**.
 
-- Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
-- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
-- Brush Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
-- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
-- Display Legend (Toggle): Description unknown as of December 2025.
-- Show Tool Notifications (Toggle): Description unknown as of December 2025.
-- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
-- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
-- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
-- Flight Intertia (Integer Slider): Description unknown as of December 2025.
-- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
-- No Clip (Toggle): Description unknown as of December 2025.
-- Air Placement (Toggle): Description unknown as of December 2025.
+- Відстань досяжності інструменту (цілочисельний повзунок): опис невідомий станом на грудень 2025 року.
+- Мінімальна затримка інструменту (цілочисельний повзунок): опис невідомий станом на грудень 2025 року.
+- Непрозорість пензля (цілочисельний  повзунок): опис невідомий станом на грудень 2025 року.
+- Непрозорість виділення (цілочисельний  повзунок): опис невідомий станом на грудень 2025 року.
+- Непрозорість панелі вибору (цілочисельний  повзунок): опис невідомий станом на грудень 2025 року.
+- Увімкнути відбивання форми пензля (перемикач): опис невідомий станом на грудень 2025 року.
+- Легенда відбивання (перемикач): Опис невідомий станом на грудень 2025 року.
+- Показувати сповіщення інструментів (перемикач): Опис невідомий станом на грудень 2025 року.
+- Лазерна указка за замовчуванням (шістнадцятковий код кольору): опис невідомий станом на грудень 2025 року.
+- Увімкнути інтервал між пензлями (перемикач): опис невідомий станом на грудень 2025 року.
+- Відстань між Br? (цілочисельний повзунок): Опис невідомий станом на грудень 2025 року.
+- Інерція польоту (цілочисельний повзунок): опис невідомий станом на грудень 2025 року.
+- Режим польоту (комбінований список: зависання, напрямок): опис невідомий станом на грудень 2025 року.
+- Без затискання (перемикач): Опис невідомий станом на грудень 2025 року.
+- Розміщення в повітрі (перемикач): Опис невідомий станом на грудень 2025 року.
 
-## Content Creation Tools
+## Інструменти створення контенту
 
-Hytale includes a variety of built-in content creation tools to help players create and edit content.
+Hytale включає різноманітні вбудовані інструменти для створення контенту, які допомагають гравцям створювати та редагувати контент.
 
-### Asset Editor
+### Редактор ресурсів проєкту
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Model Editor
+### Редактор моделей
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Asset Node Editor
+### Редактор вузлів ресурсів проєкту
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### World Tools
+### Інструменти світу
 
-These are tools that allow the user to directly edit the current world.
+Це інструменти, які дозволяють користувачеві безпосередньо редагувати поточний світ.
 
-#### Prefab Editor
+#### Редактор ресурсів проєкту
 
-Allows the user to create or edit prefabs in a separate space.
+Дозволяє користувачеві створювати або редагувати попередні ресурси проєкту в окремому просторі.
 
-##### Settings
+##### Налаштування
 
-- Saved configs (Unknown type; presumably a file)
-- Root Dir (Unknown type; presumably a folder)
-- Prefab Paths or Folders (Unknown type; presumably a list of paths or folders)
-- Recursively Search for Prefabs (Toggle)
-- Spawn Entities and NPCs (Toggle)
-- Desired Y Level to Paste (Integer)
-- Blocks Between Prefabs (Integer)
-- WorldGen Type (Combo Box: Flat, Unknown other options): Description unknown as of December 2025.
-- (Flat WorldGen Only) Num Air Blocks Below Prefabs (Integer): Description unknown as of December 2025.
-- Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
-- Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
+- Збережені конфігурації (невідомий тип; ймовірно, файл)
+- Кореневий каталог (невідомий тип; ймовірно, тека)
+- Шляхи заготовлених або теки(невідомий тип; ймовірно, список шляхів або тек)
+- Рекурсивний пошук заготовленого (перемикач)
+- Поява сутностей та неігрових персонажів (Перемикання)
+- Бажаний рівень Y для вставки (ціле число)
+- Блоки між заготовленням (ціле число)
+- Тип генерації світу (комбінований список: Плоский, Невідомо, інші варіанти): Опис невідомий станом на грудень 2025 року.
+- (Тільки для Плоского типу генерації) Кількість повітряних блоків під заготовленням (ціле число): Опис невідомий станом на грудень 2025 року.
+- Вісь для вставки (поле зі списком: X, інші параметри невідомі): опис невідомий станом на грудень 2025 року.
+- Метод вирівнювання (випадаючий список: За якорем, невідомі інші опції): опис невідомий станом на грудень 2025 року.
 
-#### Prefab List
+#### Список заготовлених
 
-- Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
-- User can pick from server, assets, or worldgen prefabs.
+- Перелічує всі заготовлення, створені користувачем, і дозволяє користувачеві завантажувати заготовлене в інструмент вставки.
+- Користувач може вибрати заготовлення сервера, ігрових ресурсів, або світової генерації.
 
-#### Spawn NPC
+#### Викликати NPC
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-#### Spawn Particle
+#### Викликати частинки
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-#### Change Player Model
+#### Змінити модель гравця
 
-- Allows the player to change their model with an adjustable scale.
+- Дозволяє гравцеві змінювати свою модель за допомогою регульованого масштабу.
 
-#### Tint Chunk
+#### Затемнення ділянки світу
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-#### Instances
+#### Примірники
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Builder Tools
+### Інструменти будівельника
 
-Unknown as of December 2025.
+Невідомий станом на грудень 2025 року.
 
-### Machinima
+### Машиніма
 
-Machinima is a built-in sequence editor, allowing the user to create and edit sequences of actions to be played back in game. It includes a built-in interactive keyframe editor.
+Машиніма - вбудований редактор послідовностей, який дозволяє користувачеві створювати та редагувати послідовності дій для відтворення в грі. Він містить вбудований інтерактивний редактор ключових кадрів.
 
-The speed of playback can be adjusted via commands.
+Швидкість відтворення можна регулювати за допомогою команд.
 
-The user may add actors for the sequence to control.
+Користувач може додавати акторів для керування послідовністю.
 
-- Reference
-- Camera
-- Entity
-- Item
-- Player
+- Приклад
+- Камера
+- Об'єкт
+- Елемент
+- Гравець
 
-## Commands
+## Команди
 
-Commands are entered into the world's chat console and begin with a forward slash `/`.
+Команди вводяться в консоль світового чату та починаються зі скісної риски `/`.
 
-- `set <block>`: allows the user to set the blocks in a selection to the specified block.
-- `inventory clear`: allows the user to clear their inventory.
+- `set <block>`: дозволяє користувачеві встановити блоки у виборі відповідно до вказаного блоку.
+- `Inventory clear`: дозволяє користувачеві очистити свій інвентар.
diff --git a/content/docs/uk-UA/established-information/server/content-categories/art-assets.mdx b/content/docs/uk-UA/established-information/server/content-categories/art-assets.mdx
index 9acebee3..fe2d3f54 100644
--- a/content/docs/uk-UA/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/uk-UA/established-information/server/content-categories/art-assets.mdx
@@ -1,123 +1,123 @@
 ---
-title: Modelling & Texturing / Art Assets
-description: Information about 3D Modelling, Texturing and Art Assets in Hytale.
+title: Моделювання та текстурування / Художні ресурси
+description: Інформація про 3D-моделювання, текстурування та художні ресурси в Hytale.
 ---
 
-# Modelling / Texture Art
+# Моделювання / Текстурне мистецтво
 
-Hytale provides comprehensive support for 3D modeling and texture art creation, with specialized tools and workflows designed to maintain the game's distinctive visual style while empowering creators.
+Hytale надає комплексну підтримку для 3D-моделювання та створення текстур, за допомогою спеціалізованих інструментів та робочих процесів, розроблених для збереження унікального візуального стилю гри, водночас надаючи розробникам можливості.
 
-## Current Mod Tooling
+## Поточні модифікаційні інструменти
 
 ### Blockbench
 
-Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
+Hytale використовує **Blockbench** як основний інструмент для 3D-моделювання та анімації:
 
-* **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
-* **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
-* **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
-* **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
+* **Офіційна підтримка**: Використовується для «створення моделей, текстур та анімації Hytale».
+* **Спеціальний плагін**: Hytale матиме спеціальний плагін Blockbench.
+* **Пряма сумісність**: Плагін дозволяє творцям «створювати моделі, текстури та анімацію, сумісні з Hytale, безпосередньо в Blockbench».
+* **Заміна застарілих інструментів**: Повна заміна старого Створювача Моделей Hytale для кращої підтримки встановлених у спільноті творчих робочих процесів
+* **Функції безпеки**: Дозволяє додавати лише матеріали, сумісні з движком, тож вам не потрібно турбуватися про можливі збої.
 
-## Model Constraints
+## Обмеження моделі
 
-### Geometry Types
+### Типи геометрії
 
-The vast majority of models in Hytale are constrained to specific geometric primitives:
+Переважна більшість моделей у Hytale обмежені певними геометричними примітивами:
 
-**3D Elements**:
+**3D-елементи**:
 
-* Blocks
-* Cuboids
-* Boxes
+* Блоки
+* Кубоїди
+* Коробки
 
-**2D Elements**:
+**2D елементи**:
 
-* Quads
-* Rectangles
-* Planes (composed of 2 triangles)
+* Квадрати
+* Прямокутники
+* Площини (складені з 2 трикутників)
 
-### Design Philosophy
+### Філософія дизайну
 
-These constraints serve multiple purposes:
+Ці обмеження служать кільком цілям:
 
-* **Performance optimization**: Ensures efficient rendering and game performance
-* **Consistent art style**: Maintains Hytale's distinctive visual aesthetic
-* **Seamless integration**: Makes mods feel more cohesive with the base game
+* Оптимізація продуктивності: забезпечує ефективну обробку графіки й високу продуктивність гри
+* **Послідовний художній стиль**: Зберігає характерну візуальну естетику Hytale
+* **Безшовна інтеграція**: Робить моди більш цілісними з базовою грою
 
-## Pixel Density Standards
+## Стандарти щільності пікселів
 
-Hytale uses different pixel densities for different types of content:
+Hytale використовує різну щільність пікселів для різних типів контенту:
 
-### Standard Densities
+### Стандартні щільності
 
-* **Blocks**: 32px density
-* **Player models**: 64px density
-* **Mobs**: Likely also 64px density
-* **Player equipment**: 64px density (weapons, cosmetics, armor, etc.)
+* **Блоки**: щільність 32 пікселів
+* **Моделі гравців**: щільність 64 пікселів
+* **Істоти**: Ймовірно, також щільність 64 пікселів
+* **Спорядження гравця**: щільність 64 пікселів (зброя, косметика, броня тощо)
 
-### Flexibility
+### Гнучкість
 
-* **Wrong density handling**: Using incorrect density may cause assets to appear at the wrong size, but will not cause import failures
-* **No strict restrictions**: Pixel ratio, rotation, and scaling are not restricted
-* **Forgiving system**: The tools are designed to be flexible while maintaining compatibility
+* **Обробка неправильної щільності**: Використання неправильної щільності може призвести до зображення ресурсів неправильного розміру, але не призведе до збоїв імпорту.
+* **Без суворих обмежень**: співвідношення пікселів, обертання та масштабування не обмежені
+* **Гнучка система**: Інструменти розроблені з урахуванням гнучкості та сумісності
 
-## Hytale Asset Editor
+## Редактор активів Hytale
 
-### In-Game Editor
+### Ігровий редактор
 
-The Asset Editor is a comprehensive tool that will ship with the game:
+Редактор активів– це комплексний інструмент, який постачатиметься разом із грою:
 
-* **Ships with game**: Available to all players from launch
-* **External tool requirement**: Does not support image editing, you must use external tools for texture creation
-* **Data asset editing**: Primary editor for working with Data Assets
-* **Expanding capabilities**: Currently supports most features, though has limitations around NPCs, worldgen, and interactions that will expand over time
+* **Поставляється з грою**: Доступно всім гравцям з моменту запуску
+* **Вимога до зовнішнього інструменту**: Не підтримує редагування зображень, для створення текстур необхідно використовувати зовнішні інструменти.
+* **Редагування активів даних**: Основний редактор для роботи з активами даних
+* **Розширення можливостей**: Наразі підтримує більшість функцій, хоча має обмеження щодо NPC, покоління світів та взаємодій, які з часом розширяться.
 
-### Particle Creation
+### Створення частинок
 
-The Asset Editor includes robust particle creation tools:
+Редактор активів містить потужні інструменти для створення частинок:
 
-* **In-game creation**: Particles are created directly in-game using the Asset Editor
-* **Industry standard**: Particle logic is robust and similar to Unity/Unreal particle systems
-* **Event-driven**: Particles can be spawned on events or interactions (like opening doors)
-* **Entity attachment**: Can attach particles to entities with specific attachment points
-* **Dynamic movement**: Supports particles moving with their anchor points
-* **Time delays**: Supports time-based particle effects and delays
+* **Створення в грі**: Частинки створюються безпосередньо в грі за допомогою редактора ресурсів
+* **Галузевий стандарт**: Логіка частинок є надійною та подібною до систем частинок Unity/Unreal
+* **Подієво-керовані**: Частинки можуть з'являтися внаслідок подій або взаємодій (наприклад, відкриття дверей).
+* **Прикріплення сутності**: Можна прикріплювати частинки до сутностей за допомогою певних точок прикріплення
+* **Динамічний рух**: Підтримує рух частинок за допомогою їхніх опорних точок
+* **Часові затримки**: Підтримує ефекти частинок та затримки на основі часу
 
-## Materials
+## Матеріали
 
-### Optimization Focus
+### Фокус на оптимізацію
 
-Hytale takes a different approach to materials compared to other engines:
+Hytale використовує інший підхід до матеріалів проти інших двигунів:
 
-* **Pre-optimized**: Materials are very optimized and artists cannot create custom materials
-* **Performance priority**: This constraint ensures consistent performance across all content
-* **Curated system**: Maintains visual consistency while maximizing efficiency
+* **Попередньо оптимізовано**: Матеріали дуже оптимізовані, і художники не можуть створювати власні матеріали
+* **Пріоритет продуктивності**: Це обмеження забезпечує стабільну продуктивність для всього контенту
+* **Кураторська система**: Зберігає візуальну узгодженість, одночасно максимізуючи ефективність
 
-## Best Practices
+## Найкращі практики
 
-### Asset Optimization
+### Оптимізація активів
 
-Key considerations from Hytale's development team:
+Ключові міркування команди розробників Hytale:
 
-* **Mindful resource usage**: Be conscious of how many blocks/quads you use and texture file sizes
-* **Avoid bloat**: Goal is to prevent unnecessary asset bloat that could impact performance
-* **Efficiency focus**: Balance visual quality with technical constraints
+* **Уважне використання ресурсів**: Звертайте увагу на кількість блоків/квадратів, які ви використовуєте, та розміри файлів текстур.
+* **Уникнення роздуття**: Мета полягає в запобіганні непотрібному роздуттю активів, яке може вплинути на продуктивність.
+* **Орієнтація на ефективність**: Збалансуйте візуальну якість із технічними обмеженнями
 
-### Future Documentation
+### Майбутня документація
 
-* **Best practice guide**: A comprehensive "best practice" guide for art and modeling will be released at some point
-* **Flexible boundaries**: Most creative goals can be achieved without breaking anything in the system
-* **Робочі процеси, керовані спільнотою**: Інструменти розроблені для підтримки усталених творчих робочих процесів у спільноті модингу.
+* **Посібник з найкращих практик**: Вичерпний посібник з «найкращих практик» для мистецтва та моделювання буде опубліковано згодом.
+* **Гнучкі межі**: Більшість творчих цілей можна досягти, не порушуючи жодних функцій системи
+* **Робочі процеси, керовані спільнотою**: Інструменти розроблені для підтримки усталених творчих робочих процесів у спільноті модифікацій.
 
-## Integration with Development Pipeline
+## Інтеграція з конвеєром розробки
 
-The modeling and texture art workflow integrates seamlessly with Hytale's broader development ecosystem:
+Робочий процес моделювання та створення текстур бездоганно інтегрується з ширшою екосистемою розробки Hytale:
 
-* **Asset Editor compatibility**: Models created in Blockbench work directly with the Hytale Asset Editor
-* **Data Asset integration**: 3D models can be configured and customized through Data Assets
-* **Visual Scripting support**: Models can be controlled and animated through Visual Scripting
-* **Java plugin extensibility**: Advanced model behaviors can be implemented through Java plugins
-* **Particle integration**: Models can have particles attached at specific points for enhanced visual effects
+* **Сумісність редактора активів**: Моделі, створені в Blockbench, працюють безпосередньо з редактором активів Hytale.
+* **Інтеграція з активами даних**: 3D-моделі можна налаштовувати та змінювати за допомогою активів даних
+* **Підтримка візуальних сценаріїв**: Моделі можна керувати та анімувати за допомогою візуальних сценаріїв
+* **Розширюваність плагінів Java**: Розширені моделі можна реалізувати за допомогою плагінів Java
+* **Інтеграція частинок**: Моделі можуть мати частинки, прикріплені в певних точках, для покращення візуальних ефектів.
 
-This integrated approach ensures that 3D modeling and texture art aren't isolated creative processes, but core components of Hytale's comprehensive development environment.
+Такий інтегрований підхід гарантує, що 3D-моделювання та створення текстур не є ізольованими творчими процесами, а основними компонентами комплексного середовища розробки Hytale.
diff --git a/content/docs/uk-UA/established-information/server/content-categories/data-assets.mdx b/content/docs/uk-UA/established-information/server/content-categories/data-assets.mdx
index d3abac85..d9f5fd7f 100644
--- a/content/docs/uk-UA/established-information/server/content-categories/data-assets.mdx
+++ b/content/docs/uk-UA/established-information/server/content-categories/data-assets.mdx
@@ -1,33 +1,33 @@
 ---
-title: Data Assets
-description: Information about data assets in Hytale and how they drive gameplay behavior and content creation.
+title: Активи даних
+description: Інформація про активи даних у Hytale та про те, як вони впливають на ігрову поведінку та створення контенту.
 ---
 
-# Data Assets
+# Активи даних
 
-Data Assets are JSON files which drive gameplay behavior and core content in Hytale. They provide a powerful, data-driven approach to creating and modifying game elements without needing to write code.
+Активи даних — це JSON-файли, які керують ігровою поведінкою та основним контентом у Hytale. Вони забезпечують потужний, керований даними підхід до створення та модифікації ігрових елементів без необхідності написання коду.
 
-## What Are Data Assets?
+## Які є активи даних?
 
-Data Assets allow you to create or modify fundamental game elements through JSON configuration files:
+Активи даних дозволяють вам створювати або змінювати фундаментальні ігрові елементи через файли конфігурації JSON:
 
-* **Blocks**: Define new block types and their properties
-* **Items**: Create custom items with unique behaviors
-* **NPCs**: Configure non-player characters and their AI
-* **World generation**: Control how the world is generated
-* **Loot tables**: Define what items drop from various sources
+* **Блоки**: Визначити нові типи блоків і їх властивості
+* **Предмети**: Створюйте власні предмети з унікальними особливостями поведінки
+* **NPC**: Налаштування неігрових персонажів та їхнього ШІ
+* **Генерація світу**: Керуйте процесом генерації світу
+* **Таблиці здобичі**: Визначте, які предмети випадають з різних джерел
 
-## Comparison to Minecraft
+## Порівняння з Minecraft
 
-Data Assets are analogous to Minecraft's data pack JSON files, but with significantly broader scope. While Minecraft's data packs are somewhat limited, Hytale's data-driven architecture means that core game elements like blocks, items, and NPCs can all be modified through JSON files.
+Активи даних подібні до JSON-файлів даних Minecraft, але мають значно ширші можливості. Хоча пакети даних Minecraft дещо обмежені, архітектура Hytale, керована даними, означає, що основні елементи гри, такі як блоки, предмети та NPC, можна змінювати за допомогою файлів JSON.
 
-This expanded data-driven approach gives modders much more power to customize the game without needing to dive into complex programming.
+Такий розширений підхід, заснований на даних, дає розробнику модифікацій набагато більше можливостей для налаштування гри без необхідності заглиблюватися у складне програмування.
 
-## Development Tools
+## Інструменти розробки
 
-Recognizing that JSON editing can be tedious and error-prone when done by hand, Hytale plans to provide multiple tools to make working with Data Assets more accessible:
+Визнаючи, що редагування JSON вручну може бути виснажливим та схильним до помилок, Hytale планує надати кілька інструментів, щоб зробити роботу з активами даних доступнішою:
 
-### Node Editor
+### Редактор вузлів
 
 Hytale is developing a "Node Editor" to make Data Asset management more user-friendly:
 
@@ -36,7 +36,7 @@ Hytale is developing a "Node Editor" to make Data Asset management more user-fri
 * **Integrated workflow**: Works directly within the Hytale Asset Editor for a unified creator suite
 * **Accessibility**: Makes complex data relationships easier to understand and modify
 
-### Additional Tools
+### Додаткові інструменти
 
 Beyond the Node Editor, Hytale plans to support:
 
@@ -56,6 +56,6 @@ Data Assets work seamlessly with Hytale's other development approaches:
 
 * **Visual Scripting**: Can reference and manipulate data defined in Data Assets
 * **Java plugins**: Can read from and modify Data Assets for more complex behaviors
-* **Asset Editor**: Provides a unified interface for managing both visual assets and their data configurations
+* \*\*Редактор активів: Забезпечує єдиний інтерфейс для управління візуальними активами та їх конфігураціями даних
 
 This integration ensures that Data Assets aren't isolated configuration files, but rather a core part of Hytale's comprehensive development environment.
diff --git a/content/docs/uk-UA/established-information/server/content-categories/visual-scripting.mdx b/content/docs/uk-UA/established-information/server/content-categories/visual-scripting.mdx
index 16cb0508..889e3abb 100644
--- a/content/docs/uk-UA/established-information/server/content-categories/visual-scripting.mdx
+++ b/content/docs/uk-UA/established-information/server/content-categories/visual-scripting.mdx
@@ -7,11 +7,11 @@ description: An introduction to what we know of Hytale's visual scripting system
 
 Hytale plans to support Visual Scripting as a method to make advanced logic and control flow accessible to a wider audience. This system will not be available at launch, but should be available shortly after launch.
 
-## Overview
+## Загальна інформація
 
 Visual Scripting in Hytale is designed to function similarly to Blueprints in Unreal Engine. It allows designers to create complex behaviors through a visual interface that matches how they think about game logic, without needing to write code directly.
 
-### Key Features
+### Основні характеристики
 
 * **Subset of Java functionality**: Visual Scripting can do a subset of what is possible with Java plugins
 * **Designer-friendly**: "Designers are empowered through a visual language that matches how they think about behaviors"
diff --git a/content/docs/uk-UA/guides/ecs/entity-component-system.mdx b/content/docs/uk-UA/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/uk-UA/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/uk-UA/guides/ecs/example-ecs-plugin.mdx b/content/docs/uk-UA/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/uk-UA/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/uk-UA/guides/ecs/hytale-ecs-theory.mdx b/content/docs/uk-UA/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/uk-UA/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/uk-UA/guides/ecs/systems.mdx b/content/docs/uk-UA/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/uk-UA/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/uk-UA/guides/java-basics/00-introduction.mdx b/content/docs/uk-UA/guides/java-basics/00-introduction.mdx
index 2b12e535..8d3f1204 100644
--- a/content/docs/uk-UA/guides/java-basics/00-introduction.mdx
+++ b/content/docs/uk-UA/guides/java-basics/00-introduction.mdx
@@ -1,50 +1,50 @@
 ---
-title: 00 - Introduction to Java
+title: 00 - Вступ до Java
 description: Посібник для початківців, що допоможе зрозуміти основи програмування на Java для модингу Hytale.
 ---
 
 Welcome to your journey into Java Programming! This guide is designed to introduce you into the basics of java.
 
-## What is Java?
+## Що таке Java?
 
 Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Найважливіше для нас, що це мова, яку Hytale використовує для своїх серверів та API модифікацій.
 
-## What You'll Learn
+## Про що ви дізнаєтесь
 
 This guide is structured to take you step-by-step through:
 
-1. Java Syntax and Basics
-2. Control Flow
-3. Object-Oriented Programming
+1. Синтаксис та основи Java
+2. Контроль потоку
+3. Об'єктно-орієнтоване програмування
 
 We will then focus on only Hytale-specific concepts. (tbd)
 
-## Setting up your Environment
+## Налаштування середовища
 
-Before we dive into programming, you'll need some essentials, you need to install:
+Перш ніж зануритися в програмування, вам знадобляться деякі необхідні компоненти, які потрібно встановити:
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
-An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
+An IDE is a software application that provides comprehensive facilities to programmers for software development. Популярні варіанти для Java:
 
 * [IntelliJ IDEA](https://www.jetbrains.com/idea/)
 * [Eclipse](https://www.eclipse.org/)
 
-## How to Use This Guide
+## Як користуватися цим посібником
 
 1. Read each article in order - Concepts build on each other
 2. Type out the examples - Don't copy-paste; typing helps you learn
 3. Experiment - Modify examples to see what happens
-4. Practice - Each article includes exercises
-5. Be patient - Programming is a skill that takes time to develop
+4. Практикуйтеся - кожна стаття містить вправи
+5. Будьте терплячі - програмування - це навичка, яка вимагає часу для розвитку
 
 ## Менталітет розробника модифікацій
 
-Modding is creative problem-solving. You'll be:
+Modding is creative problem-solving. Ви будете:
 
 * Adding new blocks, items, and creatures to Hytale
 * Changing game mechanics to create unique experiences
diff --git a/content/docs/uk-UA/guides/java-basics/01-variables.mdx b/content/docs/uk-UA/guides/java-basics/01-variables.mdx
index f884cc02..be36808a 100644
--- a/content/docs/uk-UA/guides/java-basics/01-variables.mdx
+++ b/content/docs/uk-UA/guides/java-basics/01-variables.mdx
@@ -1,19 +1,19 @@
 ---
-title: 01 - Variables & Data Types
-description: An introduction to variables and data types in Java programming.
+title: 01 - Змінні та типи даних
+description: Вступ до змінних та типів даних у програмуванні на Java.
 ---
 
-Variables are containers that store data in your program. Think of them as labeled boxes where you can put different types of information.
+Змінні - це контейнери, які зберігають дані у вашій програмі. Think of them as labeled boxes where you can put different types of information.
 
-## What is a Variable?
+## Що таке змінна?
 
 A variable has three key components:
 
 1. **Type**: What kind of data it holds (e.g., integer, string, boolean)
 2. **Name**: The label you use to refer to the variable
-3. **Value**: The data it contains
+3. **Значення**: дані, які вона містить
 
-## Declaring/Creating Variables
+## Оголошення/створення Змінних
 
 In Java, you must declare a variable before using it, like you'd need a box before putting something in it. The syntax is:
 
diff --git a/content/docs/uk-UA/guides/java-basics/06-methods-functions.mdx b/content/docs/uk-UA/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/uk-UA/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/uk-UA/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/uk-UA/guides/learning-to-learn.mdx b/content/docs/uk-UA/guides/learning-to-learn.mdx
index 0230ca75..4ab9e5c6 100644
--- a/content/docs/uk-UA/guides/learning-to-learn.mdx
+++ b/content/docs/uk-UA/guides/learning-to-learn.mdx
@@ -4,9 +4,9 @@ description: Керівництво з метою допомогти вам ст
 icon: CircleQuestionMark
 ---
 
-## Навіщо вчитися кодувати? We have visual scripting!
+## Навіщо вчитися кодувати? Ми маємо візуальний скрипт!
 
-Yes we do, and honestly you should try that out. Visual scripting is a great addition to Hytale and we know it'll be powerful, but nothing beats the ability of being able to read and write Java code, with the ability to build even more powerful mods and plugins.
+Так, і чесно кажучи, вам варто це спробувати. Visual scripting is a great addition to Hytale and we know it'll be powerful, but nothing beats the ability of being able to read and write Java code, with the ability to build even more powerful mods and plugins.
 
 <Callout type="info" title="Visual Scripting vs Coding">
   Visual scripting is great for beginners and for simple tasks, but coding allows for more complex and efficient solutions. Вивчення програмування відкриває ширший спектр можливостей для модингу Hytale.
@@ -26,7 +26,7 @@ Over the course of these next several lessons you'll learn the basics of coding,
 
 The guides themselves will take a very big "bird's-eye view" approach to things and provide links to resources to do the actual coding. This is done because, quite frankly, enough resources exist on how to learn this stuff, it's just the act of finding the right stuff on Google that can be hard. Learning to be able to code without guidance is the goal. Спільнота модингу Hytale завжди готова допомогти вам, але щоб стати справді всебічно розвиненим розробником, вам доведеться багато чого навчитися, просто читаючи ресурси.
 
-<Callout type="info" title="Finding Resources">
+<Callout type="info" title="Пошук ресурсів">
   We have created a small Java Basics series to help you get started with the language itself, but beyond that, you'll be expected to find your own resources to learn more. We recommend sites like [w3schools](https://www.w3schools.com/java/) and [GeeksforGeeks](https://www.geeksforgeeks.org/java/) as great starting points.
 </Callout>
 
@@ -34,4 +34,4 @@ Our goal is to teach you how to Mod Hytale, and that will always be our goal. Th
 
 ## Any closing thoughts?
 
-Remember, learning to code is hard. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come. Happy coding!
+Пам'ятайте, вчитися кодуванню важко. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come. Happy coding!
diff --git a/content/docs/uk-UA/guides/plugin/block-components.mdx b/content/docs/uk-UA/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/uk-UA/guides/plugin/browsing-serverjar.mdx b/content/docs/uk-UA/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/uk-UA/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/uk-UA/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/uk-UA/guides/plugin/build-and-test.mdx b/content/docs/uk-UA/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/uk-UA/guides/plugin/chat-formatting.mdx b/content/docs/uk-UA/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/uk-UA/guides/plugin/chat-formatting.mdx
+++ b/content/docs/uk-UA/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/uk-UA/guides/plugin/client-inputs-reference.mdx b/content/docs/uk-UA/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/uk-UA/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/uk-UA/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/uk-UA/guides/plugin/creating-block.mdx b/content/docs/uk-UA/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/uk-UA/guides/plugin/creating-block.mdx
+++ b/content/docs/uk-UA/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/uk-UA/guides/plugin/creating-commands.mdx b/content/docs/uk-UA/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/uk-UA/guides/plugin/creating-commands.mdx
+++ b/content/docs/uk-UA/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/uk-UA/guides/plugin/creating-configuration-file.mdx b/content/docs/uk-UA/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/uk-UA/guides/plugin/creating-events.mdx b/content/docs/uk-UA/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/uk-UA/guides/plugin/creating-events.mdx
+++ b/content/docs/uk-UA/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/uk-UA/guides/plugin/customizing-camera-controls.mdx b/content/docs/uk-UA/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/uk-UA/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/uk-UA/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/uk-UA/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/uk-UA/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/uk-UA/guides/plugin/instances.mdx b/content/docs/uk-UA/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/uk-UA/guides/plugin/inventory-management.mdx b/content/docs/uk-UA/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/uk-UA/guides/plugin/inventory-management.mdx
+++ b/content/docs/uk-UA/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/uk-UA/guides/plugin/item-interaction.mdx b/content/docs/uk-UA/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/uk-UA/guides/plugin/listening-to-packets.mdx b/content/docs/uk-UA/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/uk-UA/guides/plugin/logging.mdx b/content/docs/uk-UA/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/uk-UA/guides/plugin/player-death-event.mdx b/content/docs/uk-UA/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/uk-UA/guides/plugin/player-input-guide.mdx b/content/docs/uk-UA/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/uk-UA/guides/plugin/player-input-guide.mdx
+++ b/content/docs/uk-UA/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/uk-UA/guides/plugin/player-stats.mdx b/content/docs/uk-UA/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/uk-UA/guides/plugin/setting-up-env.mdx b/content/docs/uk-UA/guides/plugin/setting-up-env.mdx
index e8654f2a..e96d0463 100644
--- a/content/docs/uk-UA/guides/plugin/setting-up-env.mdx
+++ b/content/docs/uk-UA/guides/plugin/setting-up-env.mdx
@@ -6,9 +6,13 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
-## Prerequisites
+## Передумови
 
 Before we begin, make sure you have:
 
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/uk-UA/guides/plugin/spawning-entities.mdx b/content/docs/uk-UA/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/uk-UA/guides/plugin/spawning-entities.mdx
+++ b/content/docs/uk-UA/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/uk-UA/guides/plugin/spawning-npcs.mdx b/content/docs/uk-UA/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/uk-UA/guides/plugin/store-persistant-data.mdx b/content/docs/uk-UA/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/uk-UA/guides/plugin/teleporting-players.mdx b/content/docs/uk-UA/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/uk-UA/guides/plugin/teleporting-players.mdx
+++ b/content/docs/uk-UA/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/uk-UA/guides/plugin/text-hologram.mdx b/content/docs/uk-UA/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/uk-UA/guides/plugin/ui.mdx b/content/docs/uk-UA/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/uk-UA/guides/plugin/world-gen.mdx b/content/docs/uk-UA/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/uk-UA/guides/plugin/world-gen.mdx
+++ b/content/docs/uk-UA/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/uk-UA/guides/prefabs.mdx b/content/docs/uk-UA/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/uk-UA/guides/prefabs.mdx
+++ b/content/docs/uk-UA/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/uk-UA/official-documentation/npc-doc.mdx b/content/docs/uk-UA/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/uk-UA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/uk-UA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/uk-UA/publishing/builtbybit.mdx b/content/docs/uk-UA/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/uk-UA/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/uk-UA/publishing/index.mdx b/content/docs/uk-UA/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/uk-UA/publishing/index.mdx
+++ b/content/docs/uk-UA/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/content/docs/uk-UA/quick-start.mdx b/content/docs/uk-UA/quick-start.mdx
index a817b1b1..fab7525b 100644
--- a/content/docs/uk-UA/quick-start.mdx
+++ b/content/docs/uk-UA/quick-start.mdx
@@ -3,9 +3,9 @@ title: Швидкий старт
 description: Налаштування стандартного проєкту Hytale.
 ---
 
-Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+Ласкаво просимо до посібника з модифікування Hytale! Тут ви знайдете все, що вам потрібно знати про створення власних модифікацій для Hytale.
 
-* [Java Basics](./guides/java-basics/00-introduction)
-* [Setting up your dev environment](./guides/plugin/setting-up-env)
-* [Entity Component System (ECS)](./guides/ecs)
-* [Publishing your mod](./guides/publishing)
+* [Основи Java](./guides/java-basics/00-introduction)
+* [Налаштування середовища розробки](./guides/plugin/setting-up-env)
+* [Система компонентів сутностей (ECS)](./guides/ecs)
+* [Публікація вашого моду](./guides/publishing)
diff --git a/content/docs/vi-VN/guides/ecs/entity-component-system.mdx b/content/docs/vi-VN/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/vi-VN/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/vi-VN/guides/ecs/example-ecs-plugin.mdx b/content/docs/vi-VN/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..44743be5
--- /dev/null
+++ b/content/docs/vi-VN/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,204 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilising all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+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);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, ExamplePlugin.get().getPoisonComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+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;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/vi-VN/guides/ecs/hytale-ecs-theory.mdx b/content/docs/vi-VN/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..50b44be2
--- /dev/null
+++ b/content/docs/vi-VN/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,162 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
diff --git a/content/docs/vi-VN/guides/ecs/systems.mdx b/content/docs/vi-VN/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/vi-VN/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```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);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target 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();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```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());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```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();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```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()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```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;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/vi-VN/guides/java-basics/00-introduction.mdx b/content/docs/vi-VN/guides/java-basics/00-introduction.mdx
index 5f55d5d4..a03ad638 100644
--- a/content/docs/vi-VN/guides/java-basics/00-introduction.mdx
+++ b/content/docs/vi-VN/guides/java-basics/00-introduction.mdx
@@ -25,9 +25,9 @@ Before we dive into programming, you'll need some essentials, you need to instal
 
 ### Java Development Kit (JDK)
 
-Downlaod and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
 
-### Intergrated Development Environment (IDE)
+### Integrated Development Environment (IDE)
 
 An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
 
diff --git a/content/docs/vi-VN/guides/java-basics/06-methods-functions.mdx b/content/docs/vi-VN/guides/java-basics/06-methods-functions.mdx
index 43692e91..e8e60761 100644
--- a/content/docs/vi-VN/guides/java-basics/06-methods-functions.mdx
+++ b/content/docs/vi-VN/guides/java-basics/06-methods-functions.mdx
@@ -376,6 +376,23 @@ public static String getHealthStatus(int health, int maxHealth) {
    * Contains at least one number
    * Returns true if valid, false otherwise
 
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may be in need of a way to compare array's values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0]       // false - Java compares objects not by their location in Java's memory. 
+
+  //Instead use .equals() method - it compares objects by their values:
+  array1[0].equals(array2[0]);       // true 
+
+  //This although does not affect primitive data types.
+  ```
+</Callout>
+
 ## Common Mistakes
 
 ```java
diff --git a/content/docs/vi-VN/guides/plugin/block-components.mdx b/content/docs/vi-VN/guides/plugin/block-components.mdx
new file mode 100644
index 00000000..eec4aedf
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/block-components.mdx
@@ -0,0 +1,253 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC;
+
+    public ExampleBlock() {
+
+    }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    public void runBlockAction(int x, int y, int z, World world) {
+        world.execute(() -> {
+            world.setBlock(x + 1, y, z, "Rock_Ice");
+        });
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+
+    static {
+        CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleSystemInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+    private static final Query QUERY = Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) ->
+            {
+                Ref<ChunkStore> blockRef = blockComponentChunk1.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return QUERY;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```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 ExampleSystemInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/vi-VN/guides/plugin/browsing-serverjar.mdx b/content/docs/vi-VN/guides/plugin/browsing-serverjar.mdx
index 6f730b2c..240ed19a 100644
--- a/content/docs/vi-VN/guides/plugin/browsing-serverjar.mdx
+++ b/content/docs/vi-VN/guides/plugin/browsing-serverjar.mdx
@@ -1,13 +1,28 @@
 ---
 title: Browsing the server.jar code
-description: Learn how to patch the server.jar and browse the source code.
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
 ---
 
-The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
 
-## Setup
+## Why?
 
-- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
 
 - Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
   one of these:
@@ -19,22 +34,24 @@ The ~~patcher~~ allows you to more easily prepare an environment for exploring t
   In the last one, specifying the version is recommended if you have multiple Pythons installed.
 
 - Activate the virtual environment:
-  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
   - Linux/Mac: `source .venv/bin/activate`
   - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
 
-- Inside the venv, you have to install the dependencies
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
   - `pip install -r requirements.txt`
 
 - Install these dependencies and ensure they are on PATH:
-  - `git`
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
   - `java` you need JDK 25 or newer
   - `jar` (comes with JDK inside the bin folder)
-  - `mvn`
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
 
-## Usage
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
 
-Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
 
 Then run this:
 
@@ -42,23 +59,53 @@ Then run this:
 python run.py setup
 ```
 
-It will
+What will it do:
 
 - copy the HytaleServer.jar into `work/download`
   - (on Windows) fix `META-INF/license` name collision
-- decompile it using Fernflower and save the output to `work/decompile`
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
 - set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
 
 You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
 you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
-the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
 
-If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
-then reload the maven project:\
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
 ![_readme_images/img.png](/assets/reload-maven.png)\
 It is located in the "m" icon on the right side:\
 ![_readme_images/m.png](/assets/maven.png)\
 If you don't see it, enable it under View -> Tool Windows -> Maven.\
 ![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
-
-This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters
diff --git a/content/docs/vi-VN/guides/plugin/build-and-test.mdx b/content/docs/vi-VN/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..7e393283
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/build-and-test.mdx
@@ -0,0 +1,100 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for building your mod.
+</Callout>
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Maven
+
+Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+
+### Building with Maven
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+mvn package
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `target` directory and named:
+
+```
+ExamplePlugin-1.0-SNAPSHOT.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Press **Win + R** on your keyboard
+2. Type `%appdata%` and press Enter
+3. Navigate to: `Hytale\UserData\Mods`
+
+The full path should look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Maven
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/vi-VN/guides/plugin/chat-formatting.mdx b/content/docs/vi-VN/guides/plugin/chat-formatting.mdx
index 3b153b36..c967fc0f 100644
--- a/content/docs/vi-VN/guides/plugin/chat-formatting.mdx
+++ b/content/docs/vi-VN/guides/plugin/chat-formatting.mdx
@@ -1,9 +1,9 @@
 ---
 title: Formatting the chat
-description: Learn how to format the chat using the PlayerChatEvent
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
 authors:
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
 ---
 
 ![chat format example](/assets/guides/chat-example.png)
@@ -11,6 +11,8 @@ authors:
 The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
 You can cancel this event as well as modify the content and the formatter.
 
+## Manual Formatting (Standard Approach)
+
 ```java
 public class ChatFormatter {
 
@@ -45,3 +47,153 @@ The formatter is the following interface:
   }
 }
 ```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+Temporary until hytale plugin repository is available.
+Create libs folder in your plugin directory and place the TinyMsg jar file there.
+project/libs/TinyMessage-2.0.0-SNAPSHOT.jar
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+dependencies {
+    compileOnly(files("libs/tinymessage-2.0.0-SNAPSHOT.jar"))
+}
+```
+
+### For Maven
+
+```xml
+<dependency>
+    <groupId>fi.sulku.hytale</groupId>
+    <artifactId>tinymessage</artifactId>
+    <version>2.0.0</version>
+    <scope>provided</scope>
+    <systemPath>${project.basedir}/libs/tinymessage-2.0.0-SNAPSHOT.jar</systemPath>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/vi-VN/guides/plugin/client-inputs-reference.mdx b/content/docs/vi-VN/guides/plugin/client-inputs-reference.mdx
index 3694c5dd..a9f2f085 100644
--- a/content/docs/vi-VN/guides/plugin/client-inputs-reference.mdx
+++ b/content/docs/vi-VN/guides/plugin/client-inputs-reference.mdx
@@ -1,464 +1,94 @@
 ---
-title: Client-to-Server Inputs Reference
+title: "Packets: Client-to-Server Reference"
 description: Complete reference for every packet the client can send to the server.
 authors:
-  - name: Vibe Theory
+  - name: Vibe Theory & musava
     url: https://discord.com/users/145420279294722048
 ---
 
-## Overview
-
-This is a comprehensive list of **every packet a client can send to the server.** The client sends abstract actions, not raw keyboard input. The server never sees "W pressed" - only the resulting movement states or action requests.
-This list is not exclusive to key inputs, but rather all packets.
-
-Formatting is packet.flag, ie `MovementStates.idle` or `ClientPlaceBlock.position`
-
----
-
-## Data Structures
-
-### Enums vs Structs
-
-Packets use two types of flag/value structures:
-
-| Type       | Structure                     | Size   | Serialization                           |
-| ---------- | ----------------------------- | ------ | --------------------------------------- |
-| **Enum**   | Single value from fixed set   | 1 byte | Integer value of selected enum constant |
-| **Struct** | Multiple fields sent together | Varies | Each field serialized sequentially      |
-
-### MovementStates (Struct)
-
-Movement booleans.
-
-| Flag              | Description                 |
-| ----------------- | --------------------------- |
-| `idle`            | Not moving                  |
-| `walking`         | Walking speed               |
-| `running`         | Running speed               |
-| `sprinting`       | Sprint speed                |
-| `jumping`         | Currently jumping           |
-| `falling`         | In freefall                 |
-| `crouching`       | Sneaking/crouched           |
-| `flying`          | Creative flight             |
-| `onGround`        | Touching ground             |
-| `inFluid`         | In water/liquid             |
-| `swimming`        | Swimming motion             |
-| `climbing`        | On ladder/climbable         |
-| `gliding`         | Using glider                |
-| `rolling`         | Dodge roll                  |
-| `sitting`         | Seated                      |
-| `sleeping`        | In bed                      |
-| `mounting`        | Getting on mount            |
-| `mantling`        | Climbing ledge              |
-| `sliding`         | Sliding down slope          |
-| `horizontalIdle`  | Not moving horizontally     |
-| `forcedCrouching` | Forced crouch (low ceiling) |
-| `swimJumping`     | Jumping while swimming      |
-
-### InteractionType (Enum)
-
-Major interactions.
-
-| Value | Name               | Player Input | Description                              |
-| ----- | ------------------ | ------------ | ---------------------------------------- |
-| 0     | `Primary`          | LMB          | Primary action - attack, break block     |
-| 1     | `Secondary`        | RMB          | Secondary action - use item, place block |
-| 2     | `Ability1`         | Q            | Weapon/item ability                      |
-| 3     | `Ability2`         | —            | Reserved (no default binding)            |
-| 4     | `Ability3`         | —            | Reserved (no default binding)            |
-| 5     | `Use`              | E            | World interaction - containers, NPCs     |
-| 6     | `Pick`             | MMB          | Pick block                               |
-| 7     | `Pickup`           | —            | Item pickup (system)                     |
-| 8     | `CollisionEnter`   | —            | Collision started (system)               |
-| 9     | `CollisionLeave`   | —            | Collision ended (system)                 |
-| 10    | `Collision`        | —            | Ongoing collision (system)               |
-| 11    | `EntityStatEffect` | —            | Stat effect applied (system)             |
-| 12    | `SwapTo`           | —            | Item swapped to (system)                 |
-| 13    | `SwapFrom`         | —            | Item swapped from (system)               |
-| 14    | `Death`            | —            | Entity death (system)                    |
-| 15    | `Wielding`         | —            | Wielding state (system)                  |
-| 16    | `ProjectileSpawn`  | —            | Projectile spawned (system)              |
-| 17    | `ProjectileHit`    | —            | Projectile hit (system)                  |
-| 18    | `ProjectileMiss`   | —            | Projectile missed (system)               |
-| 19    | `ProjectileBounce` | —            | Projectile bounced (system)              |
-| 20    | `Held`             | —            | Item held (system)                       |
-| 21    | `HeldOffhand`      | —            | Item held offhand (system)               |
-| 22    | `Equipped`         | —            | Item equipped (system)                   |
-| 23    | `Dodge`            | —            | Dodge roll action                        |
-| 24    | `GameModeSwap`     | —            | Game mode changed (system)               |
-
-### BuilderToolAction (Enum)
-
-Builder tool general actions.
-
-| Value | Name                 | Default Key | Description                    |
-| ----- | -------------------- | ----------- | ------------------------------ |
-| 0     | `SelectionPosition1` | —           | Set first corner of selection  |
-| 1     | `SelectionPosition2` | —           | Set second corner of selection |
-| 2     | `SelectionCopy`      | Ctrl+C      | Copy selection to clipboard    |
-| 3     | `HistoryUndo`        | Ctrl+Z      | Undo last operation            |
-| 4     | `HistoryRedo`        | Ctrl+Y      | Redo last undone operation     |
-| 5     | `ActivateToolMode`   | B           | Enter builder tool mode        |
-| 6     | `DeactivateToolMode` | B           | Exit builder tool mode         |
-
-### InventoryActionType (Enum)
-
-Bulk inventory operations.
-
-| Value | Name         | Description                                     |
-| ----- | ------------ | ----------------------------------------------- |
-| 0     | `TakeAll`    | Take all items from container to inventory      |
-| 1     | `PutAll`     | Put all matching items into container           |
-| 2     | `QuickStack` | Quick stack matching items into container       |
-| 3     | `Sort`       | Sort container (actionData specifies sort type) |
-
-### CustomPageEventType (Enum)
-
-3 values for custom UI page events.
-
-| Value | Name          | Description                        |
-| ----- | ------------- | ---------------------------------- |
-| 0     | `Acknowledge` | Client acknowledging page action   |
-| 1     | `Data`        | Client sending data back to server |
-| 2     | `Dismiss`     | Client dismissed/closed page       |
-
----
-
-## Key → Packet Reference
-
-Summary of all default Key Mappings.
-
-| Key               | Packet                     | Package      | Notes                                             |
-| ----------------- | -------------------------- | ------------ | ------------------------------------------------- |
-| W/A/S/D           | `ClientMovement`           | player       | Movement states in packet                         |
-| Space             | `ClientMovement`           | player       | `jumping` state                                   |
-| Shift             | `ClientMovement`           | player       | `crouching` state                                 |
-| Shift (mounted)   | `DismountNPC`              | interaction  | When riding a mount                               |
-| LMB               | `MouseInteraction`         | player       | `Primary` (0)                                     |
-| RMB               | `MouseInteraction`         | player       | `Secondary` (1)                                   |
-| Q                 | `MouseInteraction`         | player       | `Ability1` (2)                                    |
-| Q (hold)          | `DropItemStack`            | inventory    | When holding item                                 |
-| E                 | `MouseInteraction`         | player       | `Use` (5)                                         |
-| MMB               | `MouseInteraction`         | player       | `Pick` (6)                                        |
-| 1-9               | `SetActiveSlot`            | inventory    | Direct slot selection                             |
-| Scroll            | `SetActiveSlot`            | inventory    | Hotbar scrolling                                  |
-| Scroll (on block) | `SwitchHotbarBlockSet`     | inventory    | Block variant cycling                             |
-| M                 | `UpdateWorldMapVisible`    | worldmap     | Map toggle                                        |
-| B                 | `BuilderToolGeneralAction` | buildertools | `ActivateToolMode` (5) / `DeactivateToolMode` (6) |
-| Ctrl+C            | `BuilderToolGeneralAction` | buildertools | `SelectionCopy` (2)                               |
-| Ctrl+Z            | `BuilderToolGeneralAction` | buildertools | `HistoryUndo` (3)                                 |
-| Ctrl+Y            | `BuilderToolGeneralAction` | buildertools | `HistoryRedo` (4)                                 |
-| ESC               | `SetPaused`                | world        | Singleplayer only                                 |
-| ESC (window open) | `CloseWindow`              | window       | Closes active window                              |
-| Enter             | `ChatMessage`              | interface_   | Sends chat/command                                |
-
----
-
-## Player
-
-Core player action packets. These are the most commonly used packets for gameplay logic - combat systems, custom abilities, movement validation, and interaction handling.
-
-| Packet                  | ID  | Fields                                                                                                                                                                                                                                                              | Description                                                                                                                                                       |
-| ----------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ClientMovement`        | 100 | `absolutePosition`, `relativePosition`, `movementStates`, `bodyOrientation`, `lookOrientation`, `velocity`, `wishMovement`, `teleportAck`                                                                                                                           | Continuous position/rotation updates. Contains either absolute position or relative delta. `teleportAck` confirms server teleports. Uses `MovementStates` struct. |
-| `MouseInteraction`      | 22  | `interactionType`, `targetEntity`, `targetBlock`, `screenPoint`                                                                                                                                                                                                     | Mouse button actions with target information. Uses `InteractionType` enum.                                                                                        |
-| `ClientPlaceBlock`      | 104 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             | Client placing a block. Contains position, rotation, and the specific block variant being placed.                                                                 |
-| `ClientReady`           | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                | Client signaling ready state. `readyForChunks` = ready to receive world data, `readyForGameplay` = fully loaded.                                                  |
-| `SyncPlayerPreferences` | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` | Client syncing player settings to server. Includes item pickup preferences and UI settings.                                                                       |
-| `LoadHotbar`            | 180 | `index`                                                                                                                                                                                                                                                             | Load a saved hotbar preset by index.                                                                                                                              |
-| `SaveHotbar`            | 181 | `index`                                                                                                                                                                                                                                                             | Save current hotbar to preset slot.                                                                                                                               |
-
----
-
-## Inventory
-
-Item and slot management packets. Useful for custom inventory rules, item restrictions, ability triggers via hotbar slots, and tracking player item usage.
-
-| Packet                  | ID  | Fields                                                               | Description                                                                               |
-| ----------------------- | --- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                   | Player changing active hotbar slot via keys 1-9 or scroll wheel.                          |
-| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId` | Dragging item from one slot to another.                                                   |
-| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                | Shift-click auto-move. `moveType` determines destination logic.                           |
-| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                           | Dropping item from inventory. Triggered by Q key (hold).                                  |
-| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                             | Cycling through block variants using scroll wheel while holding a block item.             |
-| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`            | Bulk inventory operations from UI buttons. Uses `InventoryActionType` enum.               |
-| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                   | Set/spawn item in creative inventory. `override` determines if existing item is replaced. |
-| `DropCreativeItem`      | 172 | `item`                                                               | Drop item spawned from creative menu into world.                                          |
-| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                   | Auto-place creative item (equip armor, add to hotbar, etc).                               |
-
----
-
-## Interaction
-
-Combat and entity interaction sync packets. Used for combat validation, combo systems, mount control, and NPC interaction tracking.
-
-| Packet                  | ID  | Fields      | Description                                                                                           |
-| ----------------------- | --- | ----------- | ----------------------------------------------------------------------------------------------------- |
-| `SyncInteractionChains` | 290 | `updates[]` | Synchronizes ongoing attack/ability chains between client and server for animation and hit detection. |
-| `DismountNPC`           | 294 | —           | Player requesting to dismount. Triggered by Shift key while mounted.                                  |
-
----
-
-## Interface
-
-Chat, language, and custom UI packets. Essential for command systems, chat moderation, custom menus, shops, dialogs, and any server-driven UI.
-
-| Packet            | ID  | Fields         | Description                                                                                                                                               |
-| ----------------- | --- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ChatMessage`     | 211 | `message`      | Player chat message or command. Messages starting with `/` are processed as commands. Messages starting with `.` (local commands) are rejected by server. |
-| `UpdateLanguage`  | 212 | `language`     | Player changed language preference.                                                                                                                       |
-| `CustomPageEvent` | 219 | `type`, `data` | Response to server-defined custom UI page. Uses `CustomPageEventType` enum. `data` is optional string payload (max 4MB).                                  |
-
----
-
-## Window
-
-Container and window management packets. Useful for custom container logic, crafting systems, trading interfaces, and tracking when players open/close menus.
-
-| Packet             | ID  | Fields         | Description                                                                           |
-| ------------------ | --- | -------------- | ------------------------------------------------------------------------------------- |
-| `ClientOpenWindow` | 200 | `type`         | Client requesting to open a window. Only certain window types are client-requestable. |
-| `SendWindowAction` | 201 | `id`, `action` | Client sending an action/interaction to an open window.                               |
-| `CloseWindow`      | 202 | `id`           | Client closing a window (ESC key or close button).                                    |
-
----
-
-## Worldmap
-
-Map visibility and navigation packets. Can be used as an extra keybind (M key detection), custom map overlays, teleportation systems, or death marker tracking.
-
-| Packet                       | ID  | Fields     | Description                                                                            |
-| ---------------------------- | --- | ---------- | -------------------------------------------------------------------------------------- |
-| `UpdateWorldMapVisible`      | 243 | `visible`  | Player opened or closed world map. Toggled by M key.                                   |
-| `RemoveMapMarker`            | 246 | `markerId` | Remove a marker from the map (death markers, custom markers).                          |
-| `TeleportToWorldMapMarker`   | 244 | `id`       | Request teleport to a map marker. Requires `allowTeleportToMarkers` permission.        |
-| `TeleportToWorldMapPosition` | 245 | `x`, `y`   | Request teleport to map coordinates. Requires `allowTeleportToCoordinates` permission. |
-
----
-
-## Entities
-
-Entity-related movement packets. Used for custom mount physics, mount-specific abilities, or vehicle control systems.
-
-| Packet          | ID  | Fields                                                  | Description                                                              |
-| --------------- | --- | ------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `MountMovement` | 166 | `absolutePosition`, `bodyOrientation`, `movementStates` | Position and movement states for the mount entity when player is riding. |
-
----
-
-## Camera
-
-Camera control packets. Useful for spectator systems, cinematic sequences, or admin observation tools.
-
-| Packet                 | ID  | Fields     | Description                                                                    |
-| ---------------------- | --- | ---------- | ------------------------------------------------------------------------------ |
-| `RequestFlyCameraMode` | 282 | `entering` | Request to enter or exit fly camera mode. Requires `hytale.flyCam` permission. |
-
----
-
-## Buildertools
-
-Creative mode building tool packets. Requires `hytale.editor.builderTools` permission. Can be granted to non-creative players to enable these packets as extra keybinds (B, Ctrl+Z/Y/C), or used to track/validate creative building operations.
-
-### General Actions
-
-| Packet                     | ID  | Fields   | Description                                                 |
-| -------------------------- | --- | -------- | ----------------------------------------------------------- |
-| `BuilderToolGeneralAction` | 412 | `action` | General builder tool action. Uses `BuilderToolAction` enum. |
-
-### Entity Manipulation
-
-| Packet                              | ID  | Fields                             | Description                                 |
-| ----------------------------------- | --- | ---------------------------------- | ------------------------------------------- |
-| `BuilderToolEntityAction`           | 401 | `entityId`, `action`               | Entity tool action (Freeze, Clone, Remove). |
-| `BuilderToolSetEntityTransform`     | 402 | `entityId`, `position`, `rotation` | Set entity position and rotation.           |
-| `BuilderToolSetEntityScale`         | 420 | `entityId`, `scale`                | Set entity scale.                           |
-| `BuilderToolSetEntityLight`         | 422 | `entityId`, `light`                | Set entity light properties.                |
-| `BuilderToolSetEntityPickupEnabled` | 421 | `entityId`, `enabled`              | Toggle whether entity can be picked up.     |
-| `BuilderToolSetNPCDebug`            | 423 | `entityId`, `debug`                | Toggle NPC debug mode.                      |
-
-### Selection Tools
-
-| Packet                                    | ID  | Fields      | Description                                |
-| ----------------------------------------- | --- | ----------- | ------------------------------------------ |
-| `BuilderToolSelectionUpdate`              | 409 | `selection` | Update selection bounds.                   |
-| `BuilderToolSelectionTransform`           | 405 | `transform` | Transform (move/rotate) current selection. |
-| `BuilderToolSelectionToolAskForClipboard` | 410 | —           | Request clipboard data from server.        |
-
-### Block Operations
-
-| Packet                     | ID  | Fields            | Description                               |
-| -------------------------- | --- | ----------------- | ----------------------------------------- |
-| `BuilderToolExtrudeAction` | 403 | `axis`, `amount`  | Extrude selection along axis.             |
-| `BuilderToolLineAction`    | 414 | `start`, `end`    | Draw a line of blocks between two points. |
-| `BuilderToolStackArea`     | 404 | `count`, `offset` | Stack/repeat selection multiple times.    |
-
-### Clipboard
-
-| Packet                       | ID  | Fields                | Description                  |
-| ---------------------------- | --- | --------------------- | ---------------------------- |
-| `BuilderToolRotateClipboard` | 406 | `axis`, `direction`   | Rotate clipboard contents.   |
-| `BuilderToolPasteClipboard`  | 407 | `position`, `options` | Paste clipboard at position. |
-
-### Tool Configuration
-
-| Packet                                  | ID  | Fields              | Description                                  |
-| --------------------------------------- | --- | ------------------- | -------------------------------------------- |
-| `BuilderToolArgUpdate`                  | 400 | `toolId`, `args`    | Update tool-specific arguments/settings.     |
-| `BuilderToolSetTransformationModeState` | 408 | `mode`              | Set transformation mode (move/rotate/scale). |
-| `BuilderToolOnUseInteraction`           | 413 | `position`, `block` | Tool use interaction at position.            |
-
-### Prefab
-
-| Packet                 | ID  | Fields | Description                         |
-| ---------------------- | --- | ------ | ----------------------------------- |
-| `PrefabUnselectPrefab` | 417 | —      | Deselect currently selected prefab. |
-
----
-
-## Machinima
-
-Cinematic/machinima system packets. Used for in-game cinematics, cutscenes, or replay systems.
-
-| Packet                       | ID  | Fields                                                | Description                                                                     |
-| ---------------------------- | --- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `RequestMachinimaActorModel` | 260 | `modelId`, `sceneName`, `actorName`                   | Request a model for use in machinima scene.                                     |
-| `UpdateMachinimaScene`       | 261 | `player`, `sceneName`, `frame`, `updateType`, `scene` | Update machinima scene state. Can target specific player or broadcast with `*`. |
-
----
-
-## Connection
-
-Initial connection handshake packets. Used for custom connection validation, protocol checks, or connection-time logging.
-
-| Packet       | ID | Fields                                                       | Description                                                                                              |
-| ------------ | -- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| `Connect`    | 0  | `protocolHash`, `language`, `uuid`, `username`, `clientType` | First packet sent. Contains protocol version for compatibility check, player identity, and client type.  |
-| `Disconnect` | 1  | `type`, `reason`                                             | Client notifying server it's disconnecting. Type indicates reason category (quit, timeout, kicked, etc). |
-| `Pong`       | 3  | `timestamp`                                                  | Response to server Ping for latency measurement and keepalive.                                           |
-
----
-
-## Auth
-
-Authentication packets. Used during the connection handshake for secure servers or password-protected servers.
-
-| Packet             | ID | Fields           | Description                                                                      |
-| ------------------ | -- | ---------------- | -------------------------------------------------------------------------------- |
-| `AuthToken`        | 12 | `token`, `nonce` | Client's authentication token for secure servers. Part of mutual auth handshake. |
-| `PasswordResponse` | 15 | `password`       | Client's response to server password prompt.                                     |
-
----
-
-## Setup
-
-Initial setup phase packets. Sent after connection but before gameplay. Used for enforcing render distance limits, tracking client capabilities, or custom loading logic.
-
-| Packet          | ID | Fields                    | Description                                                                                               |
-| --------------- | -- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `RequestAssets` | 23 | `assets[]`                | Client requesting specific assets (textures, models, sounds) from the server. Array of asset identifiers. |
-| `ViewRadius`    | 32 | `value`                   | Client's requested view/render distance in blocks. Server may clamp this.                                 |
-| `PlayerOptions` | 33 | `skinData`, `preferences` | Player cosmetics and client preferences sent during setup.                                                |
-
----
-
-## World
-
-World state packets. The pause packet only functions in singleplayer.
-
-| Packet      | ID  | Fields   | Description                                                         |
-| ----------- | --- | -------- | ------------------------------------------------------------------- |
-| `SetPaused` | 158 | `paused` | Pause/unpause game. Only processed in singleplayer with one player. |
-
----
-
-## Serveraccess
-
-LAN/server access configuration packets. Only functional for singleplayer world owners configuring LAN access.
-
-| Packet               | ID  | Fields               | Description                                                     |
-| -------------------- | --- | -------------------- | --------------------------------------------------------------- |
-| `UpdateServerAccess` | 251 | `hosts[]`, `access`  | Update LAN server visibility settings. Singleplayer owner only. |
-| `SetServerAccess`    | 252 | `access`, `password` | Set LAN access mode and password. Singleplayer owner only.      |
-
----
-
-## Server Events
-
-Packets with corresponding server-side events:
-
-| Packet             | Package    | Event                         | Cancellable |
-| ------------------ | ---------- | ----------------------------- | ----------- |
-| `MouseInteraction` | player     | `PlayerInteractEvent`         | Yes         |
-| `SetActiveSlot`    | inventory  | `SwitchActiveSlotEvent`       | Yes         |
-| `DropItemStack`    | inventory  | `DropItemEvent.PlayerRequest` | Yes         |
-| `ChatMessage`      | interface_ | `PlayerChatEvent`             | Yes         |
-| `Connect`          | connection | `PlayerSetupConnectEvent`     | Yes         |
-| `Disconnect`       | connection | `PlayerDisconnectEvent`       | No          |
-| `ClientReady`      | player     | `PlayerReadyEvent`            | No          |
-
----
-
-## Imports
-
-```java
-// player
-import com.hypixel.hytale.protocol.packets.player.ClientMovement;
-import com.hypixel.hytale.protocol.packets.player.MouseInteraction;
-import com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
-import com.hypixel.hytale.protocol.packets.player.ClientReady;
-import com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
-import com.hypixel.hytale.protocol.packets.player.LoadHotbar;
-import com.hypixel.hytale.protocol.packets.player.SaveHotbar;
-
-// inventory
-import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
-import com.hypixel.hytale.protocol.packets.inventory.MoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SmartMoveItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.DropItemStack;
-import com.hypixel.hytale.protocol.packets.inventory.SwitchHotbarBlockSet;
-import com.hypixel.hytale.protocol.packets.inventory.InventoryAction;
-import com.hypixel.hytale.protocol.packets.inventory.SetCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.DropCreativeItem;
-import com.hypixel.hytale.protocol.packets.inventory.SmartGiveCreativeItem;
-
-// interaction
-import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
-import com.hypixel.hytale.protocol.packets.interaction.DismountNPC;
-
-// interface_
-import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
-import com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
-import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
-
-// window
-import com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
-import com.hypixel.hytale.protocol.packets.window.SendWindowAction;
-import com.hypixel.hytale.protocol.packets.window.CloseWindow;
-
-// worldmap
-import com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
-import com.hypixel.hytale.protocol.packets.worldmap.RemoveMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
-import com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
-
-// entities
-import com.hypixel.hytale.protocol.packets.entities.MountMovement;
-
-// camera
-import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
-
-// buildertools
-import com.hypixel.hytale.protocol.packets.buildertools.*;
-
-// machinima
-import com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
-import com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
-
-// connection
-import com.hypixel.hytale.protocol.packets.connection.Connect;
-import com.hypixel.hytale.protocol.packets.connection.Disconnect;
-import com.hypixel.hy
-```
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
 
 _From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/vi-VN/guides/plugin/creating-block.mdx b/content/docs/vi-VN/guides/plugin/creating-block.mdx
index f6f65867..07b909ad 100644
--- a/content/docs/vi-VN/guides/plugin/creating-block.mdx
+++ b/content/docs/vi-VN/guides/plugin/creating-block.mdx
@@ -3,7 +3,7 @@ title: Creating custom blocks
 description: Learn how to create custom blocks for your Hytale mod.
 authors:
   - name: Flo_12344
-    link: https://flotterstudio.com
+    url: https://flotterstudio.com
 ---
 
 import { File, Folder, Files } from 'fumadocs-ui/components/files';
diff --git a/content/docs/vi-VN/guides/plugin/creating-commands.mdx b/content/docs/vi-VN/guides/plugin/creating-commands.mdx
index 4066a565..f9881d9d 100644
--- a/content/docs/vi-VN/guides/plugin/creating-commands.mdx
+++ b/content/docs/vi-VN/guides/plugin/creating-commands.mdx
@@ -3,22 +3,74 @@ title: Creating Commands
 description: Learn how to create custom commands for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: oskarscot
-    link: https://oskar.scot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
 
-## The `AbstractPlayerCommand` Class
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will amost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be prefered and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what are the servers rules are nomatter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // conetext - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
 
 To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
 
 You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
-It's important to know that `AbstractPlayerCommand` extends `AbstractAsyncCommand` meaning that commands do not execute on the main server thread.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
 
 You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
 
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
 ```java
 public class ExampleCommand extends AbstractPlayerCommand {
 
@@ -40,6 +92,308 @@ public class ExampleCommand extends AbstractPlayerCommand {
 }
 ```
 
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare 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);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// 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");
+```
+
+### Flag Arguemnts
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+The following ArgTypes are available (only lists common types):
+
+- `ArgTypes.STRING`
+- `ArgTypes.INTEGER`
+- `ArgTypes.BOOLEAN`
+- `ArgTypes.FLOAT`
+- `ArgTypes.DOUBLE`
+- `ArgTypes.UUID`
+
+### Example Command Arg Types
+
+Shows all Command arguemnt types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+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> ammount 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 decleration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+        // Optional args reguare 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 contect 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
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+
+    // Custom check example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+            .addValidator( value -> {
+                if (value != null && value <= 0) {
+                    return ValidationResult.error("ammount argument must be a positive number");
+                }
+                return ValidationResult.success();
+            });
+...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand excends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSybCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
 ## Registering the Command
 
 For any command
@@ -49,7 +403,19 @@ public class MyPlugin extends JavaPlugin {
 
     @Override
     public void setup() {
+        // One way to add commands
         this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
     }
 }
 ```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/vi-VN/guides/plugin/creating-configuration-file.mdx b/content/docs/vi-VN/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..6b733c3b
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,114 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done throught the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuartion file in the constructor of the plugin, if it is loaded after the setup is done it will throw and error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config;
+
+    public ExamplePlugin(){
+        config = this.withConfig("MyConfig", MyConfig.CODEC);
+    }
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/vi-VN/guides/plugin/creating-events.mdx b/content/docs/vi-VN/guides/plugin/creating-events.mdx
index d14a4450..ea7abdc2 100644
--- a/content/docs/vi-VN/guides/plugin/creating-events.mdx
+++ b/content/docs/vi-VN/guides/plugin/creating-events.mdx
@@ -3,9 +3,9 @@ title: Creating Events
 description: Learn how to create custom events for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
   - name: EllieAU
-    link: https://ellie.au
+    url: https://ellie.au
 ---
 
 ## Event Class
@@ -40,9 +40,9 @@ public class MyPlugin extends JavaPlugin {
 }
 ```
 
-## ESC Event Classes
+## ECS Event Classes
 
-For events that fall under the [ESC Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
 An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
 
 ```java
@@ -75,7 +75,7 @@ class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent
 }
 ```
 
-## Registering ESC Events
+## Registering ECS Events
 
 You will need to register the system in your plugin:
 
diff --git a/content/docs/vi-VN/guides/plugin/customizing-camera-controls.mdx b/content/docs/vi-VN/guides/plugin/customizing-camera-controls.mdx
index 2a946bed..e98c7777 100644
--- a/content/docs/vi-VN/guides/plugin/customizing-camera-controls.mdx
+++ b/content/docs/vi-VN/guides/plugin/customizing-camera-controls.mdx
@@ -79,6 +79,31 @@ settings.mouseInputType = MouseInputType.LookAtPlane;
 settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
 ```
 
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
 ## Common Settings Explained
 
 ### Position & Rotation
diff --git a/content/docs/vi-VN/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/vi-VN/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/vi-VN/guides/plugin/instances.mdx b/content/docs/vi-VN/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```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()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```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);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/vi-VN/guides/plugin/inventory-management.mdx b/content/docs/vi-VN/guides/plugin/inventory-management.mdx
index feb25b06..e38c644f 100644
--- a/content/docs/vi-VN/guides/plugin/inventory-management.mdx
+++ b/content/docs/vi-VN/guides/plugin/inventory-management.mdx
@@ -3,7 +3,7 @@ title: Inventory Management
 description: Learn how to manage player inventories in your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 In this guide, you'll learn how to manage player inventories in your Hytale mod.
@@ -46,7 +46,7 @@ You can create and manipulate items in a player's inventory using the `ItemStack
 To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
 
 ```java
-ItemStack item = new ItemStack("Stone"); 
+ItemStack item = new ItemStack("Stone");
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
@@ -94,17 +94,18 @@ There are also combined methods like:
 
 ## Adding `ItemStack` objects to the Inventory
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.addItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
 ```
 
 Or you can specify a certain slot to add it to:
 
 ```java
-inventory.addItemStackToSlot((short) 4, stack)
+storageContainer.addItemStackToSlot((short) 4, stack)
 ```
 
 ## Removing `ItemStack` objects from the Inventory
@@ -113,11 +114,12 @@ To remove an `ItemStack` from a player's inventory, you can use the `removeItemS
 
 ```java
 Inventory inventory = player.getInventory();
-inventory.removeItemStack(item);
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
 ```
 
 Or you can specify a certain slot to remove it from:
 
 ```java
-inventory.removeItemStackFromSlot((short) 4);
+storageContainer.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/vi-VN/guides/plugin/item-interaction.mdx b/content/docs/vi-VN/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..75709175
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/item-interaction.mdx
@@ -0,0 +1,340 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Resources/my_new_item/model.blockymodel",
+  "Texture": "Resources/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@NonNull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@NonNullDecl InteractionType interactionType, @NonNullDecl InteractionContext interactionContext, @NonNullDecl CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/vi-VN/guides/plugin/listening-to-packets.mdx b/content/docs/vi-VN/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..3fe0a422
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,183 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/vi-VN/guides/plugin/logging.mdx b/content/docs/vi-VN/guides/plugin/logging.mdx
new file mode 100644
index 00000000..c33dac2f
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it everytime.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/vi-VN/guides/plugin/player-death-event.mdx b/content/docs/vi-VN/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/vi-VN/guides/plugin/player-input-guide.mdx b/content/docs/vi-VN/guides/plugin/player-input-guide.mdx
index 30b41dbe..c9cc1419 100644
--- a/content/docs/vi-VN/guides/plugin/player-input-guide.mdx
+++ b/content/docs/vi-VN/guides/plugin/player-input-guide.mdx
@@ -1,220 +1,68 @@
 ---
-title: Player Input and Keybind Guide
-description: How to handle player input.
+title: Player Input Guide
+description: Learn how to handle player input.
 authors:
-  - name: Vibe Theory
-    url: https://discord.com/users/145420279294722048
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
 ---
 
-## The Basics
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
 
-Hytale Servers **do not receive raw keyboard input.** Instead, clients send `packets` of Interaction types:
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
 
-- **Mouse events** - clicks with target info
-- **Movement states** - 22 boolean flags (walking, jumping, etc.)
-- **Interaction types** - what action the player is performing
-
----
-
-## Keybind Limitations
-
-Due to the use of `packets` not key inputs, you cannot assign your custom Fireball spell to X.
-
-_There is a workaround addressed below, but first let's understand the baseline:_
-
-**You CANNOT:**
-
-- Add new keybinds (keyboard mapping is client-side)
-- Remap existing keys
-- Add more than 3 ability slots
-
-**You CAN:**
-
-- Intercept `packets` and hijack their purpose
-- Use 3 built-in ability slots (`Ability1`, `Ability2`, `Ability3`)
-- Make abilities item-dependent (wand = fireball, sword = slash)
-- Detect hold vs tap, double-click, toggle (via timing)
-- Full mouse control (all 5 buttons, press/release, drag)
-
-### Fixed Input Slots
-
-| Action         | Default Key | Server Receives             | Notes                   |
-| -------------- | ----------- | --------------------------- | ----------------------- |
-| Left Mouse     | LMB         | `InteractionType.Primary`   | Attack/break            |
-| Right Mouse    | RMB         | `InteractionType.Secondary` | Use/place               |
-| Weapon Ability | Q           | `InteractionType.Ability1`  | Active - weapon special |
-| Ability Slot 2 | —           | `InteractionType.Ability2`  | Unused placeholder      |
-| Ability Slot 3 | —           | `InteractionType.Ability3`  | Unused placeholder      |
-| Interact       | E           | `InteractionType.Use`       | Interact with world     |
-| Pick Block     | MMB         | `InteractionType.Pick`      | Copy block type         |
-| Dodge          | —           | `InteractionType.Dodge`     | Dodge roll mechanic     |
-
-**Note:** Only `Ability1` (Q key) is actively used for weapon abilities. `Ability2` and `Ability3` exist in the enum but have no default keybinds and nothing in the codebase references them: they appear to be reserved for future use.
-
-These are the only keyboard actions the server sees.
-
----
-
-## Intercepting Packets
-
-This is the work around to Custom Player Keybinds. By intercepting the input packets you can redirect the event trigger to your own class. There is a **major caveat with this strategy:** This will override the default Key Mapping unless you otherwise redirect it.
-
-See [Client Input Reference](https://hytalemodding.dev/en/docs/guides/plugin/client-inputs-reference) for a comprehensive list of all client-to-server packets.
-
-For instance, intercepting Q to use for custom Fireball spell = Hytale Weapon Abilities becoming unusable.
-
-This is because you aren't intercepting Q, but rather `InteractionType.Ability1`. You would need to redirect a different packet into those recreated abilities in your own mod (this will also of course hijack another packet). The Client Input Reference above shows all packets. _Pro Tip: Builder tools when not in creative are a great starting point._
-
-### Example: Builder Tools -> Combat Abilities
-
-This is one of the better systems to capture, as it intercepts packets not even used during standard play.
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
 
 ```java
-// 1. Grant permission on join (in PlayerReadyEvent handler)
-PermissionsModule.get().addUserPermission(
-    playerRef.getUuid(),
-    Set.of("hytale.editor.builderTools")
-);
-
-// 2. Intercept in packet handler
-void handleBuilderToolAction(BuilderToolGeneralAction packet, PlayerRef playerRef) {
-    Ref<EntityStore> ref = playerRef.getReference();
-    if (ref == null) return;
-    
-    Store<EntityStore> store = ref.getStore();
-    Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
-    
-    if (playerComponent.getGameMode() != GameMode.Creative) {
-        // Hijack for abilities
-        switch (packet.action) {
-            case ActivateToolMode -> castFireball(playerRef);   // B pressed
-            case DeactivateToolMode -> endFireball(playerRef);  // B released
-            case HistoryUndo -> castRewind(playerRef);          // Ctrl+Z
-            case HistoryRedo -> castHaste(playerRef);           // Ctrl+Y
-            case SelectionCopy -> castClone(playerRef);         // Ctrl+C
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
         }
-        return;  // Don't run actual builder tool logic
-    }
-    // Creative players get normal behavior
-    super.handleBuilderToolAction(packet, playerRef);
-}
-```
-
-You can do this with anything, so a custom keybind for UI, gameplay, etc.
-
-**Critical Note:** If the player changes keybinds you won't know, so your guides have to reference Default Hytale Controls. Also if they change key binds due to your mod (disliking Ctrl+C as an ability for example) the setting follows them, and may impact their experience outside of your ecosystem. Important to consider while choosing packets.
-
-###
-
----
-
-## Mouse Inputs
-
-Some useful info about mouse inputs
-
-### Listening to Mouse Clicks
-
-```java
-@Override
-protected void setup() {
-    getEventRegistry().register(PlayerMouseButtonEvent.class, event -> {
-        MouseButtonEvent mouse = event.getMouseButton();
-
-        if (mouse.mouseButtonType == MouseButtonType.Left
-                && mouse.state == MouseButtonState.Pressed) {
-            // Left click!
-            Entity target = event.getTargetEntity();
-            Vector3i block = event.getTargetBlock();
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
         }
-
-        // Cancel the click
-        // event.setCancelled(true);
-    });
-}
-```
-
----
-
-### Mouse Button Types
-
-```java
-MouseButtonType.Left    // Primary click
-MouseButtonType.Right   // Secondary click
-MouseButtonType.Middle  // Scroll wheel click
-MouseButtonType.X1      // Side button 1
-MouseButtonType.X2      // Side button 2
-```
-
-```java
-MouseButtonState.Pressed   // Button down
-MouseButtonState.Released  // Button up
-```
-
----
-
-### What You Get From Mouse Events
-
-| Property            | Type             | Description                     |
-| ------------------- | ---------------- | ------------------------------- |
-| `getMouseButton()`  | MouseButtonEvent | Button type, state, click count |
-| `getTargetEntity()` | Entity           | Entity under cursor (or null)   |
-| `getTargetBlock()`  | Vector3i         | Block position under cursor     |
-| `getItemInHand()`   | Item             | Currently held item             |
-| `getScreenPoint()`  | Vector2f         | Cursor screen position          |
-| `getPlayer()`       | Player           | The player who clicked          |
-
-**Double-click detection:**
-
-```java
-if (mouse.clicks >= 2) {
-    // Double-clicked!
+    }
 }
 ```
 
-### Imports
-
-```java
-import com.hypixel.hytale.protocol.MouseButtonType;
-import com.hypixel.hytale.protocol.MouseButtonState;
-import com.hypixel.hytale.protocol.MouseButtonEvent;
-import com.hypixel.hytale.protocol.InteractionType;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseButtonEvent;
-import com.hypixel.hytale.server.core.event.events.player.PlayerMouseMotionEvent;
-```
-
----
-
-### Available Player Events
-
-All player events that can be registered via `getEventRegistry()`:
-
-| Event                        | Description                     |
-| ---------------------------- | ------------------------------- |
-| `PlayerConnectEvent`         | Player connecting to server     |
-| `PlayerDisconnectEvent`      | Player disconnecting            |
-| `PlayerSetupConnectEvent`    | Connection setup phase          |
-| `PlayerSetupDisconnectEvent` | Disconnect setup phase          |
-| `PlayerReadyEvent`           | Player fully loaded and ready   |
-| `PlayerChatEvent`            | Chat message sent               |
-| `PlayerInteractEvent`        | Interaction with world/entities |
-| `PlayerMouseButtonEvent`     | Mouse button press/release      |
-| `PlayerMouseMotionEvent`     | Mouse movement                  |
-| `PlayerCraftEvent`           | Item crafted                    |
-| `AddPlayerToWorldEvent`      | Player added to a world         |
-| `DrainPlayerFromWorldEvent`  | Player removed from world       |
-
----
-
-## Tips
-
-- **1 ability slot active**: Only `Ability1` (Q) is currently used - make it item-dependent
-- **Cancel events**: Use `event.setCancelled(true)` to block the action
-- **Movement states**: Check these in systems for continuous monitoring
-- **Double-click**: Check `mouse.clicks >= 2`
-- **Hold vs tap**: Track press/release timing yourself
-- **Target info**: Events include what block/entity the player was targeting
-- **No move event**: Poll `TransformComponent` or check `MovementStates` instead
-
----
-
-_From Hytale Server build `2026.01.13-dcad8778f`_
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/vi-VN/guides/plugin/player-stats.mdx b/content/docs/vi-VN/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/vi-VN/guides/plugin/setting-up-env.mdx b/content/docs/vi-VN/guides/plugin/setting-up-env.mdx
index e8654f2a..8115e634 100644
--- a/content/docs/vi-VN/guides/plugin/setting-up-env.mdx
+++ b/content/docs/vi-VN/guides/plugin/setting-up-env.mdx
@@ -6,6 +6,10 @@ authors:
     link: https://itsneil.dev
 ---
 
+<Callout type="warning">
+  This guide is outdated and will be updated soon. Whilst this guide is still accurate, there are now better alternatives for setting up your environment.
+</Callout>
+
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
 
 ## Prerequisites
@@ -40,6 +44,15 @@ java -version
 brew install openjdk@25
 ```
 
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
 #### Linux (Ubuntu/Debian)
 
 ```bash
@@ -55,7 +68,9 @@ We recommend IntelliJ IDEA Community Edition for Hytale modding.
 2. Install with default settings
 3. Launch and complete the initial setup wizard
 
-### 3) Maven
+### 3) Java Build Tool
+
+We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -66,19 +81,7 @@ You can now try the command `mvn -version` to verify Maven is installed correctl
 
 ## Setting Up Your Workspace
 
-### 1. Add HytaleServer.jar Dependency
-
-Before you can start modding, you need to add the HytaleServer.jar file as a dependency:
-
-1. **Download HytaleServer.jar** using the [Hytale Downloader](https://support.hytale.com/hc/en-us/articles/45326769420827-Hytale-Server-Manual)
-2. **Add to IntelliJ IDEA**:
-   - Click on **"File"** at the top left
-   - Go to **"Project Structure"**
-   - Go to **"Libraries"**
-   - Click on the **+ icon**
-   - Select the **HytaleServer.jar** you downloaded
-
-### 2) Clone the Plugin Template
+### 1. Clone the Plugin Template
 
 Instead of creating an empty directory, we'll use the official Hytale plugin template:
 
@@ -88,13 +91,68 @@ git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
 cd MyFirstMod
 ```
 
-### 3. Open in IntelliJ IDEA
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDEA
 
 1. Open IntelliJ IDEA
 2. Click "Open" and navigate to your `MyFirstMod` directory
 3. IntelliJ will automatically detect it as a Maven project
 4. Wait for the project to index and dependencies to download
 
+### 3) Hytale Dependency
+
+Before you can start modding, you need to make sure that your plugin has the necessary dependencies to interact with Hytale's API. The plugin template already includes the Hytale server dependency in its `pom.xml` file. Depending on the version of Hytale you want to target, you may need to adjust the version number in the `pom.xml` file:
+
+```xml
+<project>
+    <repositories>
+        <!-- Hytale release repository -->
+        <repository>
+            <id>hytale-release</id>
+            <url>https://maven.hytale.com/release</url>
+        </repository>
+        <!-- Hytale pre-release repository -->
+        <repository>
+            <id>hytale-pre-release</id>
+            <url>https://maven.hytale.com/pre-release</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>2026.01.22-6f8bdbdc4</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+<Callout type="info">
+  If you are using Gradle instead of Maven, ensure your `build.gradle` file includes the Hytale repositories and dependencies accordingly. As example:
+
+  ```
+  repositories {
+      mavenCentral()
+      maven {
+          name = "hytale-release"
+          url = uri("https://maven.hytale.com/release")
+      }
+      maven {
+          name = "hytale-pre-release"
+          url = uri("https://maven.hytale.com/pre-release")
+      }
+  }
+
+  dependencies {
+      compileOnly("com.hypixel.hytale:Server:2026.01.22-6f8bdbdc4")
+  }
+  ```
+</Callout>
+
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
@@ -103,9 +161,10 @@ Now that you have your development environment set up with the plugin template:
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
-The plugin template includes:
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
 
-- Pre-configured Gradle build system
-- Example plugin structure
-- Essential dependencies
-- Development tools configuration
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/vi-VN/guides/plugin/spawning-entities.mdx b/content/docs/vi-VN/guides/plugin/spawning-entities.mdx
index 97afb996..e12c0aea 100644
--- a/content/docs/vi-VN/guides/plugin/spawning-entities.mdx
+++ b/content/docs/vi-VN/guides/plugin/spawning-entities.mdx
@@ -39,7 +39,10 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
-  To use the `store` variable we got above, we need to run this inside the world. You can do so by using the `world.execute()` method:
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
 
   ```java
   world.execute(() -> {
@@ -67,10 +70,10 @@ Model model = Model.createScaledModel(modelAsset, 1.0f);
 
 The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
 
-1. Getting the Transform Component from the `Player` object
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
 
 ```java
-TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
 ```
 
 2. Generating a new TransformComponent
@@ -106,8 +109,12 @@ holder.ensureComponent(Interactable.getComponentType()); // if you want your ent
 
 ## Spawning the Entity
 
-Finally, we can spawn the entity in the world by calling the `spawnEntity` method on the `EntityStore` instance:
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
 
 ```java
-store.spawnEntity(holder, AddReason.SPAWN);
+store.addEntity(holder, AddReason.SPAWN);
 ```
diff --git a/content/docs/vi-VN/guides/plugin/spawning-npcs.mdx b/content/docs/vi-VN/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// 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");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```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);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/vi-VN/guides/plugin/store-persistant-data.mdx b/content/docs/vi-VN/guides/plugin/store-persistant-data.mdx
new file mode 100644
index 00000000..5893025f
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/store-persistant-data.mdx
@@ -0,0 +1,140 @@
+---
+title: Storing Persistant Data on the Player
+description: Learn how to save and load persistant data using Components
+authors:
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  Since the codec system is lambda based, you provide a setter and getter for each field.
+
+  Using complex data types (like Lists, Maps, etc) is possible, but can get tricky.
+  Refer to the available Codec types in the `Server.jar/com/hypixel/hytale/codec/` package for more information on what types are available.
+
+  Note that the 'key' used in the KeyedCodec must start with a Capital Letter, otherwise it may not serialize properly.
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .addField(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addField(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .addField(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @NullableDecl
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@NonNullDecl JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/plugin/hytale-ecs-theory) guide.
diff --git a/content/docs/vi-VN/guides/plugin/teleporting-players.mdx b/content/docs/vi-VN/guides/plugin/teleporting-players.mdx
index bef0d9b7..57cee77f 100644
--- a/content/docs/vi-VN/guides/plugin/teleporting-players.mdx
+++ b/content/docs/vi-VN/guides/plugin/teleporting-players.mdx
@@ -14,7 +14,10 @@ public static void teleportPlayer(Player player, int x, int y, int z) {
         world.execute(() -> {
             if (player.getReference() == null) return;
             Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = new Teleport(new Transform(x ,y, z));
+            Teleport teleport = Teleport.createForPlayer(world,
+                new Vector3d(x ,y, z), // Target position
+                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
+            );
 
             store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
         });
diff --git a/content/docs/vi-VN/guides/plugin/text-hologram.mdx b/content/docs/vi-VN/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @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());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/vi-VN/guides/plugin/ui.mdx b/content/docs/vi-VN/guides/plugin/ui.mdx
new file mode 100644
index 00000000..dcb6eb5d
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/ui.mdx
@@ -0,0 +1,256 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
diff --git a/content/docs/vi-VN/guides/plugin/world-gen.mdx b/content/docs/vi-VN/guides/plugin/world-gen.mdx
index 37cdddac..4c23b0c9 100644
--- a/content/docs/vi-VN/guides/plugin/world-gen.mdx
+++ b/content/docs/vi-VN/guides/plugin/world-gen.mdx
@@ -3,7 +3,7 @@ title: World Generation System
 description: Learn how to create custom world generation features for your Hytale mod.
 authors:
   - name: Neil Revin
-    link: https://itsneil.dev
+    url: https://itsneil.dev
 ---
 
 # Overview
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Eacdh zone defines it's own cave patterns:
+Each zone defines it's own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/vi-VN/guides/prefabs.mdx b/content/docs/vi-VN/guides/prefabs.mdx
index c258f63b..08404b30 100644
--- a/content/docs/vi-VN/guides/prefabs.mdx
+++ b/content/docs/vi-VN/guides/prefabs.mdx
@@ -4,7 +4,7 @@ description: Documentation about Prefabs in Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
-    link: https://bencres.dev
+    url: https://bencres.dev
 ---
 
 # Introduction
diff --git a/content/docs/vi-VN/official-documentation/npc-doc.mdx b/content/docs/vi-VN/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..a63f805b
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Documentation
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/vi-VN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/vi-VN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..38809fad
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale
+
+## What's an Asset Pack
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..44528376
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..5e34acd4
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHoritontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx b/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
new file mode 100644
index 00000000..e97a9edc
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/how-to-edit-and-create-biomes.mdx
@@ -0,0 +1,156 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+icon: Pencil
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+Server/HytaleGenerator/..
+```
+
+<div className="flex flex-row gap-2">
+  <div className="flex-1">
+    ```
+    ../WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Density
+    ```
+
+    Density assets that can be referenced by other generation assets.
+  </div>
+
+  <div className="flex-1">
+    ```
+    ../Assignments
+    ```
+
+    Prop assets that can be referenced by Biome assets.
+  </div>
+</div>
+
+---
+
+### How to visit our worlds
+
+{/* [Video] */}
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require a "world Instance config" to be setup with a generator that will allow you to visit your work.
+
+```
+Server/Instances/..
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json title="instance.bson"
+"WorldGen": {
+  "Type": "HytaleGenerator",
+  "WorldStructure": "Basic",
+  "playerSpawn" : {
+    "X" : 123,
+    "Y" : 480,
+    "Z" : 10000,
+    "Pitch" : 0,
+    "Yaw" : 0,
+    "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout type="info">
+  You can create your own world Instance that points to a custom World Structure asset for testing your work. You can do this by duplicating the basic Instance config and changing the `WorldStructure` key to the name of your asset.
+</Callout>
+
+---
+
+### How to edit Biomes
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing Tab.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FELlTzG4Md2UXWFrSHNpH%2Fimage.png?alt=media&#x26;token=8bb07167-1fb3-40d3-be2c-89319bbebbd5" alt=""><figcaption></figcaption></figure> */}
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory.;
+
+```
+Server/HytaleGenerator/Biomes/Basic.json
+```
+
+<Callout type="warning">
+  You must have an Asset Pack with a Biome.
+</Callout>
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+{/* <figure><img src="https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FmidvNuRr6h8A1fPDt0B6%2Fimage.png?alt=media&#x26;token=726892fd-9bac-4ba4-b15d-6e91fcc8a3e2" alt=""><figcaption></figcaption></figure> */}
+
+<Callout type="info">
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+#### Terrain
+
+Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+
+#### Material Provider
+
+Logical nodes that determine what materials make up a Biome's terrain.
+
+#### Props
+
+Object function nodes that add objects such as prefabs to the terrain.
+
+Configure content positioned locally in your world such as trees, POIs, grass, and so on. These nodes allow you to configure where the content is placed and what it places.
+
+#### Environment Provider
+
+Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+
+#### Tint Provider
+
+Logical function nodes that determine a color code that can be used by certain material types. Typically this will be grasses and soils.
+
+### How to preview your work
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.;
+
+```
+/viewport --radius 5
+```
+
+You can also create a new world to show your changes.;
+
+```
+/instances spawn <instance>
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx b/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
new file mode 100644
index 00000000..7bf23597
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts.mdx
@@ -0,0 +1,149 @@
+---
+title: World Generation Concepts
+description: Explores the basic concepts of world generation in the context of Hytale.
+icon: Globe
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# World Generation Concepts
+
+### Generative **Noise**
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="my-auto flex-3/4 border-r pr-4">
+    Hytale's terrain generation is founded on this concept of Density fields,
+    essentially these are maps of decimal values that are used to define the
+    terrain's shape. Density fields can be built from sources of procedural
+    noise (such as [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) and
+    Cellular), contextual data and processing nodes.
+  </div>
+
+  <div className="flex-1/4 pl-4">
+    ![White
+    Noise](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise.png)
+  </div>
+</div>
+
+### **Noise based terrain**
+
+A basic terrain shape can be created by combining a set of heights with a noise field, this formula creates most of the terrain in Hytale. This is an important concept to understand as its foundational to making terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Terrain</span> <br /> 3-dimensional terrain
+    output.
+  </div>
+
+  <div className="flex-1 border-r px-2">
+    <span className="font-bold">Simplex 2D</span> <br /> Generative
+    2-dimensional noise field.
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Y-Curve</span> <br /> 2-dimensional curve drawn
+    between a height differential.
+  </div>
+</div>
+
+![Graphs about Noise Based Terrain](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/noise-based-terrain.png)
+
+#### Solidity
+
+Density generates a range of values, typically between 1 and -1. Some of these values will become our terrain and others will become the negative space, or air, around our terrain.
+
+<div className="flex flex-row rounded-lg border p-4 text-center">
+  <div className="flex-1 border-r pr-2">
+    <span className="font-bold">Density</span> <br />
+    Density values are calculated at each coordinate, you can imagine this is
+    like a cloud ![Graph about
+    Density](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/density.png)
+  </div>
+
+  <div className="flex-1 pl-2">
+    <span className="font-bold">Solidity</span> <br />
+    Typically, we interpret positive values account for solid terrain, and
+    negative values the empty space ![Graph about
+    Solidity](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/solidity.png)
+  </div>
+</div>
+
+#### Function Nodes
+
+All of our Density fields can be manipulated with a range of function nodes provided in our node editor. These have a range of functionality that can be used to make interesting terrain shapes - a list of these can be found below.
+
+<Callout type="info">
+  Density is calculated from the sum, this can be thought of like a traditional
+  math equation `f(x) = z + y`
+</Callout>
+
+Below we cover some basic examples that are important to understand when creating some of your first terrain.
+
+##### Absolute
+
+In this example, absolute makes all negative values positive. This makes a kind of ridged shape on a simplex noise field.
+
+![Graph about Absolute](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/absolute.png)
+
+##### Normalization
+
+Its important to understand how to manipulate a noise field into a new range. This is because some functions affect the range of your field.
+
+In this example we are normalizing our previous example so that half of the field is empty and half solid. This is done by moving our 0 value to -1, stretching the field to our new range.
+
+![Graph about Normalization](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/normalization.png)
+
+<Callout type="warning">
+  Currently the Hytale Node Editor does not support noise visualization, but a
+  range of examples of function nodes can be found in
+  `HytaleGenerator/Biomes/Examples/`
+</Callout>
+
+### Material Providers
+
+Materials use a number of logical function nodes to determine which block asset is used at which location. These can be run on both solid portions of the terrain field but also on negative portions to fill in a water level for example. Some examples of this can be found below.
+
+#### Solidity
+
+Splits into two Material Providers, one for all positive values which becomes solid, the other for negatives which become empty.
+
+#### Queue
+
+Creates a queue of materials with the top node coming highest in priority and the bottom the lowest priority.
+
+<Callout type="danger">
+  The Hytale Node Editor currently sets node priority based on a node's position
+  in the editor, this is displayed as a number in the top right corner of the
+  node.
+</Callout>
+
+### Props
+
+Props enable you to generate content in a specific limited region. Hytale has a range of different Prop types that you can use to build content that gets procedurally added to the world. You can define where the content places by using a combination of Positions fields, Scanners and Patterns.
+
+<div className="flex flex-col rounded-lg border p-4">
+  <div className="flex flex-row text-center">
+    <div className="flex-1 border-r pr-2">
+      <span className="font-bold">Positions</span> <br />
+      Provides the locations to scan in.
+    </div>
+
+    <div className="flex-1 border-r px-2">
+      <span className="font-bold">Scanner</span> <br />
+      An area or column around each position to scan, finds the locations that
+      match the Pattern.
+    </div>
+
+    <div className="flex-1 pl-2">
+      <span className="font-bold">Pattern</span> <br />
+      The Pattern that defines what are valid positions based on the contents of
+      the world.
+    </div>
+  </div>
+
+  ![Graph about
+  Props](/assets/official-documentation/worldgen/worldgen-tutorial/world-generation-concepts/props.png)
+</div>
diff --git a/content/docs/vi-VN/publishing/builtbybit.mdx b/content/docs/vi-VN/publishing/builtbybit.mdx
new file mode 100644
index 00000000..3d5715a6
--- /dev/null
+++ b/content/docs/vi-VN/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $3.99 for paid content)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $3.99 for paid content (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/vi-VN/publishing/index.mdx b/content/docs/vi-VN/publishing/index.mdx
index 0545a04f..fb60fa35 100644
--- a/content/docs/vi-VN/publishing/index.mdx
+++ b/content/docs/vi-VN/publishing/index.mdx
@@ -3,12 +3,13 @@ title: Publishing Your Mod
 description: Learn how to publish your mod to the community.
 ---
 
-Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, etc.
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
 
 We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
 
 - [Publishing on Modtale](./publishing/modtale)
 - [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
 
 <Callout>
   If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
diff --git a/messages/af-ZA.json b/messages/af-ZA.json
index 9f94d1c4..a0e8e78c 100644
--- a/messages/af-ZA.json
+++ b/messages/af-ZA.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Failed to load.",
     "gitInfoUnavailable": "Git info not available",
     "credit": "Written by",
-    "supportUs": "Support Us"
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Basics"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Community Projects"
     }
diff --git a/messages/ar-SA.json b/messages/ar-SA.json
index 7be395c2..adc12006 100644
--- a/messages/ar-SA.json
+++ b/messages/ar-SA.json
@@ -37,7 +37,11 @@
     "failedToLoad": "تعذّر التحميل.",
     "gitInfoUnavailable": "معلومات Git غير متوفرة",
     "credit": "كتب بواسطة",
-    "supportUs": "إدعمنا"
+    "supportUs": "إدعمنا",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "أساسيات جافا"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "مشاريع المجتمع"
     }
diff --git a/messages/cs-CZ.json b/messages/cs-CZ.json
new file mode 100644
index 00000000..320e91dd
--- /dev/null
+++ b/messages/cs-CZ.json
@@ -0,0 +1,93 @@
+{
+  "displayName": "English",
+  "nav": {
+    "title": "Hytale Modding",
+    "documentation": "Documentation",
+    "sponsors": "Sponsors",
+    "search": "Search"
+  },
+  "home": {
+    "title": "#1 Resource for Hytale Modding {flipwords}",
+    "flipwords": [
+      "Guides",
+      "Documentation",
+      "Tools",
+      "Tutorials"
+    ],
+    "description": "The number one community resource for modding Hytale, featuring\ncomprehensive guides, detailed documentation, and essential tools to\nkickstart your modding journey.",
+    "documentation": "Docs",
+    "forum": "Forum",
+    "discord": "Join the community!",
+    "memberCount": "{count} Members",
+    "countdown": "Hytale releases in {countdown}",
+    "countdownUnits": {
+      "hours": "h",
+      "minutes": "m",
+      "seconds": "s"
+    },
+    "hytaleReleased": "Hytale is out!"
+  },
+  "sponsors": {
+    "title": "Support Us",
+    "description": "HytaleModding is an open-source community project, and part of managing the community involves paying for services, servers and infrastructure, like hosting this website. If you would like to support the project, consider becoming a sponsor! We use OpenCollective so you can see how funds are being used to support the community.",
+    "ourSponsors": "Our Sponsors"
+  },
+  "misc": {
+    "loading": "Loading...",
+    "failedToLoad": "Failed to load.",
+    "gitInfoUnavailable": "Git info not available",
+    "credit": "Written by",
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
+  },
+  "meta": {
+    "established_information": {
+      "title": "Established Information",
+      "separator": "Specific Categories",
+      "server": {
+        "title": "Server",
+        "content_categories": {
+          "title": "Content Categories"
+        },
+        "interface": {
+          "title": "Interface"
+        }
+      },
+      "client": {
+        "title": "Client"
+      },
+      "gameplay": {
+        "title": "Gameplay"
+      },
+      "misc": {
+        "title": "Miscellaneous"
+      }
+    },
+    "guides": {
+      "title": "Guides",
+      "java_basics": {
+        "title": "Java Basics"
+      }
+    },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
+    "community_projects": {
+      "title": "Community Projects"
+    }
+  }
+}
diff --git a/messages/da-DK.json b/messages/da-DK.json
index 0b04d794..f2996300 100644
--- a/messages/da-DK.json
+++ b/messages/da-DK.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Indlæsning mislykkedes.",
     "gitInfoUnavailable": "Git information er ikke tilgængelig",
     "credit": "Skrevet af",
-    "supportUs": "Støt Os"
+    "supportUs": "Støt Os",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Grundlæggende Java"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Community Projekter"
     }
diff --git a/messages/de-DE.json b/messages/de-DE.json
index f7e7fa06..5c92b19a 100644
--- a/messages/de-DE.json
+++ b/messages/de-DE.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Fehler beim Laden.",
     "gitInfoUnavailable": "Git Info nicht verfügbar",
     "credit": "Geschrieben von",
-    "supportUs": "Unterstütze uns"
+    "supportUs": "Unterstütze uns",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Grundlagen"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Community-Projekte"
     }
diff --git a/messages/es-ES.json b/messages/es-ES.json
index ae1da78f..070f263a 100644
--- a/messages/es-ES.json
+++ b/messages/es-ES.json
@@ -11,7 +11,7 @@
     "flipwords": [
       "Guías",
       "Documentación",
-      "Tools",
+      "Herramientas",
       "Tutoriales"
     ],
     "description": "El recurso comunitario número uno para mods de Hytale, con guías exhaustivas, documentación detallada y herramientas esenciales para que empiece su viaje de modding.",
@@ -19,13 +19,13 @@
     "forum": "Foro",
     "discord": "¡Únete a la comunidad!",
     "memberCount": "{count} miembros",
-    "countdown": "Hytale releases in {countdown}",
+    "countdown": "Hytale se estrenará en {countdown}",
     "countdownUnits": {
       "hours": "h",
       "minutes": "m",
       "seconds": "s"
     },
-    "hytaleReleased": "Hytale is out!"
+    "hytaleReleased": "¡Hytale se ha estrenado!"
   },
   "sponsors": {
     "title": "Apóyenos",
@@ -37,7 +37,11 @@
     "failedToLoad": "Error al cargar.",
     "gitInfoUnavailable": "La información de Git no está disponible",
     "credit": "Redactado por",
-    "supportUs": "Apóyenos"
+    "supportUs": "Apóyenos",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Conceptos básicos de Java"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Proyectos de la comunidad"
     }
diff --git a/messages/fr-FR.json b/messages/fr-FR.json
index 419d93bc..5028bd16 100644
--- a/messages/fr-FR.json
+++ b/messages/fr-FR.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Échec du chargement.",
     "gitInfoUnavailable": "Informations de git indisponibles",
     "credit": "Écrit par",
-    "supportUs": "Soutenez-nous"
+    "supportUs": "Soutenez-nous",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Bases de Java"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Projets de la communauté"
     }
diff --git a/messages/hi-IN.json b/messages/hi-IN.json
index dfe2a926..364ba2bc 100644
--- a/messages/hi-IN.json
+++ b/messages/hi-IN.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Failed to load.",
     "gitInfoUnavailable": "Git जानकारी उपलब्ध नहीं है",
     "credit": "Written by",
-    "supportUs": "Support Us"
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Basics"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Community Projects"
     }
diff --git a/messages/hu-HU.json b/messages/hu-HU.json
index 7b4ad630..9d3cedaf 100644
--- a/messages/hu-HU.json
+++ b/messages/hu-HU.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Sikertelen betöltés.",
     "gitInfoUnavailable": "Git adatok nem elérhetőek.",
     "credit": "Készítette",
-    "supportUs": "Támogatás"
+    "supportUs": "Támogatás",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java alapok"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Közösségi projektek"
     }
diff --git a/messages/id-ID.json b/messages/id-ID.json
index cf9a53bb..c7359d95 100644
--- a/messages/id-ID.json
+++ b/messages/id-ID.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Failed to load.",
     "gitInfoUnavailable": "Git info not available",
     "credit": "Written by",
-    "supportUs": "Support Us"
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Basics"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Community Projects"
     }
diff --git a/messages/it-IT.json b/messages/it-IT.json
index da47d6bd..f87e6266 100644
--- a/messages/it-IT.json
+++ b/messages/it-IT.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Caricamento fallito.",
     "gitInfoUnavailable": "Informazioni di Git non disponibili",
     "credit": "Scritto da",
-    "supportUs": "Sostienici"
+    "supportUs": "Sostienici",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Fondamenti Di Java"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Progetti della comunità"
     }
diff --git a/messages/ja-JP.json b/messages/ja-JP.json
index 4572efe3..ce395a8e 100644
--- a/messages/ja-JP.json
+++ b/messages/ja-JP.json
@@ -19,13 +19,13 @@
     "forum": "フォーラム",
     "discord": "コミュニティに参加する",
     "memberCount": "{count}人のメンバー",
-    "countdown": "Hytale releases in {countdown}",
+    "countdown": "Hytaleはあと{countdown}でリリースされます",
     "countdownUnits": {
-      "hours": "h",
-      "minutes": "m",
-      "seconds": "s"
+      "hours": "時間",
+      "minutes": "分",
+      "seconds": "秒"
     },
-    "hytaleReleased": "Hytale is out!"
+    "hytaleReleased": "Hytaleがリリースされました！"
   },
   "sponsors": {
     "title": "支援する",
@@ -37,16 +37,20 @@
     "failedToLoad": "ロードに失敗しました",
     "gitInfoUnavailable": "Gitリポジトリの情報が見つかりません",
     "credit": "著者",
-    "supportUs": "支援する"
+    "supportUs": "支援する",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
-      "title": "Established Information",
-      "separator": "Specific Categories",
+      "title": "確立された情報",
+      "separator": "特定のカテゴリ",
       "server": {
         "title": "サーバー",
         "content_categories": {
-          "title": "Content Categories"
+          "title": "コンテンツカテゴリ"
         },
         "interface": {
           "title": "インターフェイス"
@@ -68,6 +72,20 @@
         "title": "Javaの基本"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "コミュニティプロジェクト"
     }
diff --git a/messages/lt-LT.json b/messages/lt-LT.json
index 5f673ad9..de633b3e 100644
--- a/messages/lt-LT.json
+++ b/messages/lt-LT.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Failed to load.",
     "gitInfoUnavailable": "Git info not available",
     "credit": "Written by",
-    "supportUs": "Paremkite mus"
+    "supportUs": "Paremkite mus",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Pagrindai"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Bendruomenės Projektai"
     }
diff --git a/messages/lv-LV.json b/messages/lv-LV.json
index 7cb70818..6ecb6b1f 100644
--- a/messages/lv-LV.json
+++ b/messages/lv-LV.json
@@ -19,13 +19,13 @@
     "forum": "Forums",
     "discord": "Pievienojies kopienai!",
     "memberCount": "{count} Biedri",
-    "countdown": "Hytale releases in {countdown}",
+    "countdown": "Hytale izlaidīs {countdown}",
     "countdownUnits": {
       "hours": "h",
       "minutes": "m",
       "seconds": "s"
     },
-    "hytaleReleased": "Hytale is out!"
+    "hytaleReleased": "Hytale ir iznācis!"
   },
   "sponsors": {
     "title": "Atbalsti Mūs",
@@ -37,7 +37,11 @@
     "failedToLoad": "Neizdevās ielādēt.",
     "gitInfoUnavailable": "Git info nav pieejams",
     "credit": "Rakstīja",
-    "supportUs": "Atbalsti Mūs"
+    "supportUs": "Atbalsti Mūs",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Pamati"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Kopienas Projekti"
     }
diff --git a/messages/nl-NL.json b/messages/nl-NL.json
index b66ef2cf..7b69e1ce 100644
--- a/messages/nl-NL.json
+++ b/messages/nl-NL.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Laden is mislukt.",
     "gitInfoUnavailable": "Git informatie niet beschikbaar",
     "credit": "Geschreven door",
-    "supportUs": "Steun ons"
+    "supportUs": "Steun ons",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": ""
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Community projecten"
     }
diff --git a/messages/pl-PL.json b/messages/pl-PL.json
index c96d8a94..e0a75cc4 100644
--- a/messages/pl-PL.json
+++ b/messages/pl-PL.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Nie udało się wczytać.",
     "gitInfoUnavailable": "Informacje z Git'a niedostępne",
     "credit": "Napisane przez",
-    "supportUs": "Wesprzyj Nas"
+    "supportUs": "Wesprzyj Nas",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Podstawy Java"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Poradnik Worldgen"
+        }
+      }
+    },
     "community_projects": {
       "title": "Projekty Społeczności"
     }
diff --git a/messages/pt-BR.json b/messages/pt-BR.json
index d12e4f08..866e7359 100644
--- a/messages/pt-BR.json
+++ b/messages/pt-BR.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Falha ao carregar.",
     "gitInfoUnavailable": "Informações do Git indisponíveis",
     "credit": "Escrito por",
-    "supportUs": "Apoie-nos"
+    "supportUs": "Apoie-nos",
+    "officialDocumentationNotice": {
+      "title": "Documentação oficial do Hytale",
+      "description": "Todo o conteúdo desta seção é fornecido pela **Hypixel Studios Canada Inc.** e é apresentado sem alterações substanciais, exceto por ajustes de design visual realizados pela equipe Hytale Modding."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Fundamentos do Java"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "Geração de mundo",
+        "pack_tutorial": {
+          "title": "Tutorial do pacote da geração de mundo"
+        },
+        "technical_hytale_generator": {
+          "title": "Gerador técnico do Hytale"
+        },
+        "worldgen_tutorial": {
+          "title": "Tutorial da geração de mundo"
+        }
+      }
+    },
     "community_projects": {
       "title": "Projetos da comunidade"
     }
diff --git a/messages/pt-PT.json b/messages/pt-PT.json
index 2dea1a24..320e91dd 100644
--- a/messages/pt-PT.json
+++ b/messages/pt-PT.json
@@ -1,19 +1,93 @@
 {
-  "displayName": "Português",
-
+  "displayName": "English",
   "nav": {
     "title": "Hytale Modding",
-    "documentation": "Documentation"
+    "documentation": "Documentation",
+    "sponsors": "Sponsors",
+    "search": "Search"
   },
   "home": {
-    "community": "Community",
-    "title": "Hytale Modding",
-    "welcome": "Welcome to Hytale Modding!",
-    "welcomeDescription": "This is an unofficial community for modding Hytale, providing guides, documentation, and resources.",
-    "documentation": "Documentation",
-    "discord": "Discord"
+    "title": "#1 Resource for Hytale Modding {flipwords}",
+    "flipwords": [
+      "Guides",
+      "Documentation",
+      "Tools",
+      "Tutorials"
+    ],
+    "description": "The number one community resource for modding Hytale, featuring\ncomprehensive guides, detailed documentation, and essential tools to\nkickstart your modding journey.",
+    "documentation": "Docs",
+    "forum": "Forum",
+    "discord": "Join the community!",
+    "memberCount": "{count} Members",
+    "countdown": "Hytale releases in {countdown}",
+    "countdownUnits": {
+      "hours": "h",
+      "minutes": "m",
+      "seconds": "s"
+    },
+    "hytaleReleased": "Hytale is out!"
+  },
+  "sponsors": {
+    "title": "Support Us",
+    "description": "HytaleModding is an open-source community project, and part of managing the community involves paying for services, servers and infrastructure, like hosting this website. If you would like to support the project, consider becoming a sponsor! We use OpenCollective so you can see how funds are being used to support the community.",
+    "ourSponsors": "Our Sponsors"
   },
   "misc": {
-    "gitInfoUnavailable": "Git info not available"
+    "loading": "Loading...",
+    "failedToLoad": "Failed to load.",
+    "gitInfoUnavailable": "Git info not available",
+    "credit": "Written by",
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
+  },
+  "meta": {
+    "established_information": {
+      "title": "Established Information",
+      "separator": "Specific Categories",
+      "server": {
+        "title": "Server",
+        "content_categories": {
+          "title": "Content Categories"
+        },
+        "interface": {
+          "title": "Interface"
+        }
+      },
+      "client": {
+        "title": "Client"
+      },
+      "gameplay": {
+        "title": "Gameplay"
+      },
+      "misc": {
+        "title": "Miscellaneous"
+      }
+    },
+    "guides": {
+      "title": "Guides",
+      "java_basics": {
+        "title": "Java Basics"
+      }
+    },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
+    "community_projects": {
+      "title": "Community Projects"
+    }
   }
 }
diff --git a/messages/ro-RO.json b/messages/ro-RO.json
index bfc23a10..cfbc012e 100644
--- a/messages/ro-RO.json
+++ b/messages/ro-RO.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Failed to load.",
     "gitInfoUnavailable": "Git info not available",
     "credit": "Written by",
-    "supportUs": "Support Us"
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Basics"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Community Projects"
     }
diff --git a/messages/ru-RU.json b/messages/ru-RU.json
index 623912fa..e4514ce0 100644
--- a/messages/ru-RU.json
+++ b/messages/ru-RU.json
@@ -7,19 +7,19 @@
     "search": "Поиск"
   },
   "home": {
-    "title": "#1 Ресурс для Моддинга Hytale",
+    "title": "#1 Ресурс для модмейкеров Hytale ",
     "flipwords": [
-      "Руководства",
+      "Гайды",
       "Документация",
-      "Ресурсы",
-      "Инструкции"
+      "Инструменты",
+      "Туториалы"
     ],
     "description": "Лучший ресурс для моддинг комьюнити Hytale, включающий в себя\nподробные гайды, документацию и все необходимые инструменты, чтобы начать свое путешествие в мир моддинга.",
     "documentation": "Документация",
     "forum": "Форум",
-    "discord": "Присоединись нашей коммьюнити!",
+    "discord": "Присоединяйтесь к нашему сообществу!",
     "memberCount": "{count} Участников",
-    "countdown": "Hytale releases in {countdown}",
+    "countdown": "Hytale выйдет через",
     "countdownUnits": {
       "hours": "ч",
       "minutes": "мин",
@@ -28,8 +28,8 @@
     "hytaleReleased": "Hytale вышел!"
   },
   "sponsors": {
-    "title": "Поддержи нас",
-    "description": "HytaleModding — это проект сообщества с открытым исходным кодом. Для его работы мы оплачиваем сервисы, серверы и инфраструктуру, включая хостинг этого сайта. Если вы хотите поддержать проект, станьте спонсором! Мы используем OpenCollective, поэтому вы всегда можете видеть, на что именно идут собранные средства.",
+    "title": "Поддержите нас",
+    "description": "HytaleModding — это проект сообщества с открытым исходным кодом. Для его работы мы оплачиваем сервисы, сервера и инфраструктуру, включая хостинг этого сайта. Если вы хотите поддержать проект, станьте спонсором! Мы используем OpenCollective, поэтому вы всегда можете видеть, на что именно идут собранные средства.",
     "ourSponsors": "Наши спонсоры"
   },
   "misc": {
@@ -37,7 +37,11 @@
     "failedToLoad": "Не удалось загрузить.",
     "gitInfoUnavailable": "Git недоступен",
     "credit": "Автор",
-    "supportUs": "Поддержи нас"
+    "supportUs": "Поддержи нас",
+    "officialDocumentationNotice": {
+      "title": "Официальная документация Hytale",
+      "description": "Все материалы этого раздела предоставлены **Hypixel Studios Canada Inc. * и не содержат каких-либо существенных изменений, помимо визуальных корректировок, сделанных командой HytaleModding."
+    }
   },
   "meta": {
     "established_information": {
@@ -46,7 +50,7 @@
       "server": {
         "title": "Сервер",
         "content_categories": {
-          "title": "Категории Контента"
+          "title": "Категории контента"
         },
         "interface": {
           "title": "Интерфейс"
@@ -63,11 +67,25 @@
       }
     },
     "guides": {
-      "title": "Руководства",
+      "title": "Гайды",
       "java_basics": {
         "title": "Основы Java"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "Генерация мира",
+        "pack_tutorial": {
+          "title": "Туториал по пакам генератора мира"
+        },
+        "technical_hytale_generator": {
+          "title": "Изменения технических свойств генератора мира Hytale"
+        },
+        "worldgen_tutorial": {
+          "title": "Туториал по генерации мира"
+        }
+      }
+    },
     "community_projects": {
       "title": "Проекты от коммьюнити"
     }
diff --git a/messages/sq-AL.json b/messages/sq-AL.json
new file mode 100644
index 00000000..320e91dd
--- /dev/null
+++ b/messages/sq-AL.json
@@ -0,0 +1,93 @@
+{
+  "displayName": "English",
+  "nav": {
+    "title": "Hytale Modding",
+    "documentation": "Documentation",
+    "sponsors": "Sponsors",
+    "search": "Search"
+  },
+  "home": {
+    "title": "#1 Resource for Hytale Modding {flipwords}",
+    "flipwords": [
+      "Guides",
+      "Documentation",
+      "Tools",
+      "Tutorials"
+    ],
+    "description": "The number one community resource for modding Hytale, featuring\ncomprehensive guides, detailed documentation, and essential tools to\nkickstart your modding journey.",
+    "documentation": "Docs",
+    "forum": "Forum",
+    "discord": "Join the community!",
+    "memberCount": "{count} Members",
+    "countdown": "Hytale releases in {countdown}",
+    "countdownUnits": {
+      "hours": "h",
+      "minutes": "m",
+      "seconds": "s"
+    },
+    "hytaleReleased": "Hytale is out!"
+  },
+  "sponsors": {
+    "title": "Support Us",
+    "description": "HytaleModding is an open-source community project, and part of managing the community involves paying for services, servers and infrastructure, like hosting this website. If you would like to support the project, consider becoming a sponsor! We use OpenCollective so you can see how funds are being used to support the community.",
+    "ourSponsors": "Our Sponsors"
+  },
+  "misc": {
+    "loading": "Loading...",
+    "failedToLoad": "Failed to load.",
+    "gitInfoUnavailable": "Git info not available",
+    "credit": "Written by",
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
+  },
+  "meta": {
+    "established_information": {
+      "title": "Established Information",
+      "separator": "Specific Categories",
+      "server": {
+        "title": "Server",
+        "content_categories": {
+          "title": "Content Categories"
+        },
+        "interface": {
+          "title": "Interface"
+        }
+      },
+      "client": {
+        "title": "Client"
+      },
+      "gameplay": {
+        "title": "Gameplay"
+      },
+      "misc": {
+        "title": "Miscellaneous"
+      }
+    },
+    "guides": {
+      "title": "Guides",
+      "java_basics": {
+        "title": "Java Basics"
+      }
+    },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
+    "community_projects": {
+      "title": "Community Projects"
+    }
+  }
+}
diff --git a/messages/sv-SE.json b/messages/sv-SE.json
index 30420206..f804c3ed 100644
--- a/messages/sv-SE.json
+++ b/messages/sv-SE.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Kunde inte ladda",
     "gitInfoUnavailable": "Git info inte tillgänglig",
     "credit": "Skrivet av",
-    "supportUs": "Stötta oss"
+    "supportUs": "Stötta oss",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Basics"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Gemenskapsprojekt"
     }
diff --git a/messages/tr-TR.json b/messages/tr-TR.json
index 1149f4d2..1f02ee20 100644
--- a/messages/tr-TR.json
+++ b/messages/tr-TR.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Yüklenemedi.",
     "gitInfoUnavailable": "Git bilgisi bulunamadı",
     "credit": "Yazan",
-    "supportUs": "Bizi Destekle"
+    "supportUs": "Bizi Destekle",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Temelleri"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Topluluk Projeleri"
     }
diff --git a/messages/uk-UA.json b/messages/uk-UA.json
index 7807d799..9edb1415 100644
--- a/messages/uk-UA.json
+++ b/messages/uk-UA.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Не вдалося завантажити.",
     "gitInfoUnavailable": "Інформація Git не доступна",
     "credit": "Написана",
-    "supportUs": "Підтримати нас"
+    "supportUs": "Підтримати нас",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Основи Java"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Проєкти спільноти"
     }
diff --git a/messages/vi-VN.json b/messages/vi-VN.json
index 421a3d9d..ef5b9904 100644
--- a/messages/vi-VN.json
+++ b/messages/vi-VN.json
@@ -37,7 +37,11 @@
     "failedToLoad": "Failed to load.",
     "gitInfoUnavailable": "Git info not available",
     "credit": "Written by",
-    "supportUs": "Support Us"
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
   },
   "meta": {
     "established_information": {
@@ -68,6 +72,20 @@
         "title": "Java Basics"
       }
     },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
     "community_projects": {
       "title": "Dự án cộng đồng"
     }